android_frameworks_base

	name
No matching files

Updated OMAP support

Adds updated TI code (under the OMAP_ENHANCEMENT conditional) for
compatibility with the current version of OMAP3/OMAP4 kernel-side
code.

This is a squashed combination of 138 commits from omapzoom:

Stagefright OMXCodec changes to enable TI Hardware Codecs

Descritpion:
These changes are ported from Froyo branch. The change details:
(1) Decoder table is updated with TI Ducati codec components
(2) OMX version is updated
(3) Component quirks are modified as per ducati codec requirements
(4) Codec configuration parameters are modified as per ducati codec
requirements

Change-Id: If845c3464281a1be053dbbff85c8db56b1163286
Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Stagefright changes for video thumnail generation

Descritpion: These changes are ported from Froyo branch.
The change details:
(1) OMXCodec changes for quirks, bufferallocation
(2) Colorconverter changes to support strided buffer color conversion
from NV-12 packed to RGB
(3) stagefright metadata retriever changes for codec create with proper
flags and codec configuration changes required for Ducati codec

Change-Id: I252284d9e98653d9cccc46521e6391f1d439e90a
Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Stagefright Changes to use externally allocated buffers

Description: These changes are ported from Froyi branch.
The change details:
(1) Video Renderer and OMXRenderer interface changes to pass buffers
from Renderer to Awesome player
(2) Awesoem player changes to set the buffers with the OMXCodec
and release the buffers once rendered
(3) OMXCodec changes to use the externally allocated buffers
while configuring the hardware codec.

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 5: Cherry-picked on current tree. No changes made.
Taking verifications and approvals from previous patch sets.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I39e1c014eb52f9b0c2cb717671d0339889b09e07

Stagefright changes to support interlaced video formats

Description: These changes are ported from Froyo branch
Change details:
(1) Stagefrightmetadata retriever changes to check the video content
and configure teh OMXCodec with appropriate flags.
(2) OMX Codec changes to update the quirks and configure codec accordingly.

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 4 Cherry-picked on current head of tree. No changes
made. Taking verifications and approvals from previous patch sets.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Change-Id: Ia2e79d3883b2359ea416d5fcf509c4f3c38358e2

Stagefright changes for H263 decoders

Desrciption: These changes are ported from Froyo branch.
The change details:
H263 mime type and color format checks are added.

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 4 : Cherry-picked on current head of tree. No changes
made. Taking verifications and approvals from previous patch sets.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Change-Id: Iafac582a0b426503533fcd53f62d3ced91b89b15

OMXCodec changes for buffer alignment

Description: These changes are ported from Froyo branch
The change details:
A constant has been defined to make buffer size aligned on 32 bit boundary

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 4 : Cherry-picked on current head of tree. No changes
made. Taking verifications and approvals from previous patch sets.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Change-Id: I8e8850eaa907966fd9670a57a254c1328cfb1478

Non-PreAnnouncement mode for thumbnail generation

Description: These changes are ported from Froyo
Since tiler memory is limited we cannot have 2 instance of decoder 1 instance of encoder
and camera running in parallel. This is a requirement from 1080p camcorder perceptive.
To save tiler memory we are allocating only 2 actual full size buffers but remaining all
buffers as dummy. The dummy buffer will help us to move to idle state. Then we would provide
full allocate buffers only to ducati and then on receiving the Third EmptyThisBufferDone we
would send an EOS. This will flush out the Decoded first I frame buffer back to the component.
This is the frame from which we will make the thumbnail.

Here we have not voilated any OMX protocol but still able to save memory. This is called as
NON-PreAnnoucement mode where we dont give all the actual buffer to the OMX component before
Hand for mapping on the accelerator

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 4: Cherry-picked on current head of tree. No changes
made. Taking verifications and approvals from previous patch sets.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Icd9650f2aa51a2eb919b51962f4c9e61ca763fe5

OMXCodec changes for software codec

Descritpion: These changes are ported from Froyo
change details:
(1) property based checks are added for software codecc

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>
Patch Set 4: Cherry-picked on current head of tree. No changes
made. Taking verifications and approvals from previous patch sets.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Change-Id: I3cd522ecaf69f8d46877fd89f10000550fbd8622

OMXCodec changes to add software decoders/encoders to the list

Description: The codecs table is updated with the Android software codecs.

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 2: cherry-pick on current tree. No changes made.
Verifications and approvals taken from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Change-Id: I4fdcf597fe087b54f6be10c0ad93dea0ce24bdce

OMX Renderer changres for on-the-fly resize support

Description: These changes are ported from Froyo.
Change details:
(1) Renderer interface is extended for resize
(2) Init Renderer is modified to call resize instead of destroy renderer,
if teh rendere is already created.

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 4: Cherry-picked on current head of tree. No changes
made. Taking verifications and approvals from previous patch sets.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Change-Id: I519ba180cf652cf16ea7579e98c8a5278a16d790

Stagefright media extractor and parser changes

Description: These changes are ported from Froyo branch.
The change details:
(1) Extended MPEG4 extractor to support more format types
(2) Addition of cutom enums for openmax formats and errors

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 4: Cherry-picked on new tree. No changes made.
Taking verifications and approvals from previous patch
sets.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: If28b1605ea9e75f453adab7499095b5f69348af9

Stagefright and Surfaceflinger changes for S3D

Description: These changes are ported from Froyo
Change details:
(1) custom SEI parser is added
(2) Renderer creation is overloaded for s3d
(3) Awesome player has been modified to create the appropriate renderer
(4) Surface flinger is modified for appropriate overlay creation

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 7: Cherry-picking patch 4 on current head. No changes made.
Taking verifications and approvals from patch set 4. Just reuploading
to get description right.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Change-Id: I9e8824ac88279bacf6ad9e71dd2a94e6fefd9c73

StageFright Audio fixes

Description: These changes are ported from Froyo
Change details:
(1) Audio flush function is added
(2) quirks are updated for MP3 and AAC codecs
(3) mpeg4 extractor is updated for amr codecs

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 4: Cherry-picked on current tree. No changes made.
Taking verifications and approvals from patch set 3.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Ic9f351b8b251aa29d36e1805014f27184c1dff22

Mediaplayer & AwesomePlayer changes for Video Cloning

The changes are for porting the below patch from Froyo to Gingerbread
----------------------------------------------------------
http://review.omapzoom.org/#change,9754

Description# MediaPlayer interface and video Renderer interfaces have been
extended for enabling and disabling video cloning. Awesome receives the
Video mode state from mediaplayer and sets the renderer accordingly.

----------------------------------------------------------

Signed-off-by:<dnk.mohan@ti.com>

Patch Set 2: Cherry-picked on current tree. No changes made.
Taking approvals and verifications from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I0eeec627987c16cf54e361cafb927809493629a1

Awesomeplayer changes for Video Cloning on HDMI after application suspend/resume

The changes are for porting the below patch from Froyo to Gingerbread
----------------------------------------------------------
http://review.omapzoom.org/#change,10447

Description# when Gallery app is suspended by pressing home button, MediaPlayer
gets suspended and underlying Renderer and overlay are destroyed. But the
Awesomeplayer is just reset. Hence the Videomode (normal or Clone) is left
to the last value set before the suspend.
Once the application is resumed, and tries to set the clone mode again,
it would be filtered at the AwesomePlayer level because of the cached value.
This is fixed by resetting the Video mode to normal while resetting the
Awesomeplayer.
----------------------------------------------------------

Signed-off-by:<dnk.mohan@ti.com>

Patch set 2: Cherry-picked on current tree. No changes made.
Taking verifications and approvals from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Ie346c1a81b976ad56cfd7be675a26368556caf35

Stagefright: Updating meta data with profile,level,referenceframe data. Communicate to AVC component

The changes are for porting the below patch from Froyo to Gingerbread
----------------------------------------------------------
http://review.omapzoom.org/#change,9467

- Added support to parse and save Video profile,level, scan-type,number of reference frames in meta data
- Communicate to ducati component
- Removed earlier isinterlaced() interface, and replaced with more updatemetadata() call in TIVideoConfigParser.cpp
----------------------------------------------------------

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch set 4: No changes made. Cherry-pick on current tree.
Taking verification, approvals and build test from patch set 3.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I1bb89f27a19ac53461f0ed98a54b7adbee6c66a6

Flush the audio sink when resuming from a pause-->seek

The changes are for porting the below patch from Froyo to Gingerbread
----------------------------------------------------------
http://review.omapzoom.org/#change,9462

1) Play an audio file
2) Pause playback
3) Seek to another position in the file
4) Resume playback
... some audio from the position before the seek is played before the audio at the new position is played.
This patch resolves the issue by flusing the audio sink before resuming the playback if there had been a seek
while the audio was paused
----------------------------------------------------------

Signed-off-by:<dnk.mohan@ti.com>

Patch set 3: Cherry-pick on current tree. No changes made.
Taking verifications, approvals and build test from patch set
2.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Ic2b135473f4400cbcc92b4f2906e482f07aa4c1f

Improve AV sync logic for accurate frame posting

Current logic:
1. On Play a 10msec defalt event is posted which has a callback onVideoEvent in awesomeplayer.cpp.
2. If we find a frame in renderer comming from Ducati then we check its time stamp against system / audio time stamp
3. There is a start delta which is always adjusted from the current time.
4. If the frame is late by 50 msec we drop it
5. If the frame is early more than 100 msec then we post a event after 10msec
6. if the frame is within 10 msec of current time then post it.
7. After a frame is posted we trigger a 10msec event to go to next frame

Flaws in current logic
1. we will never post it accurate; a 33 msec frame will get divided in three 10 msec windows and we will post it 3 mec early.
2. 100 msec check was wrong.
3. polling every 10 msec is increasing the MHZ
4. After displaying the frame we start a 10msec event which could have been 1 Msec to get more accurate posting results
5. Audio on OMAP4 increase the timestamp after 42 msec and we need accuracy of 1msec. So we will never have a precise posting

Modified logic
1. We check 10msec for early ness as per google original logic. Required for precise posting
2. For PPM optimization 2 things are done
1. Post the first frame event after 1 msec instead of 10 msec
2. Post the exact time future event for frame posting
e.g 33 msec we will have 1 msec and 32 msec 2 polls only reducing the ARM MHZ and also having precise posting of frame
3. Increase accuracy of audio by interpolating in between 2 audio frame increments. So polling in between 42 msec also provides
accurate results and keeps audio buffer sizes independent of AV sync logic
4. Added safety check so that if audio dies we dont keep playing video via interpolating logic.
5. A safety modulation logic is added so that if we seek we dont wait in the event for huge time.
This will cause hangs if we dont do this in seek case.
6. Added few instrumentation to know the exact delta between to postings
Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 2: Failed rebase.

Patch set 3: Cherry-pick on current tree. No changes made.
Taking verifications, and approvals from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Ic5651df3a8e657c123c670b11724e043218fb349

OMAP4:Stagefright player changes to use Codec recommended number of O/P buffers

Description: Currently there is no communication between OMX codec configuration
and the TIHardware renderer wrt the number of Overlay buffers to be used for
on the output port. In this patch, the Awesome player logic is enhanced to
query Codec for the recommended number of buffers for output port and
communicate the same down to TI Hardware Renderer. The codec recommended number
is buffered with the optimal buffer count to be maintained at the DSS driver.
With this patch the hardcoding for the output port buffer number is removed
and also the lower limit for the buffer count is removed in TIHardware Renderer.
this patch has to be merged along with 1.21-p5 ducati migration.

Validation: Tested AV playback from Android Gallery for different resolution cl$

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch set 2: Cherry-pick on current tree. No changes made.
Taking verifications, approvals and build test from patch set
1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I7d858108e8768294ded1b2fc2c2887429f8968a7

OMAP3: create mCodecSpecificData without CodecConfig flag

This fixes a case that encoder returns the first buffer not
including CodecConfig. In case of OMX.TI.Video.encoder using
MPEG4 or H.264, the encoder does not return the CodecConfig
buffer but returns CodecConfig and the first encoded data
in one buffer without OMX_BUFFERFLAG_CODECCONFIG flag set.
Concerning the compatibility of Froyo and GB, this regards only
MPEG4Writer issue in GB.

Change-Id: Ie4d541fd6d3ae540eebbdebed0ef235ec0d557e7
Signed-off-by: keun-o.park <sahara@ti.com>

H264 encoder fixes for OMAP4

logic put in for OMAP3 h264 encoder is breaking OMAP4 h264 encoder.
Making change OMAP3 specific. Also fixing debug compilation error.

Signed-off-by: Dandawate Saket <dsaket@ti.com>

Patch Set 3: Simple Cherry-pick on tree. Taking approvals,
verfications from patch set 2. No changes made.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Iebfd4ca74b0c7c15c4bb504399653baa8a4e4a65

OMAP: Stagefright: Added rotation support to S3D Renderer.

OMX in Gingerbread need new HardwareAPI, createRendererWithRotation
to create rotated overlay for play video clips which have rotation info.
OMAP used old-fashion createRenderer to pass platform specific args,
such as isS3D, numOfOpBuffers but, no rotation degrees passed.

The function, createRendererWithRotation dynamically loaded
from libstagefrighthw.so only if it is defined. If not,
createRenderer will be loaded just like old times.

Change-Id: I440637aab1ba9c68fdb6eeb413095cf3814b5dad
Signed-off-by: Homin Lee <homin.lee@ti.com>

Gingerbread Camcorder : Generic Encoder chnages.

Description : These cahnges are generic to all the encoders. It sets the
port configurations, I/p & O/p buffers count, Quirks for
i/p * o/p ports, stride information & other generic ducati settings.

Signed Off By : Sreenidhi Koti <sreenidhi@ti.com>

Patch Set 4: Cherry-picking on current tree. Merge conflict resolved.
Taking approvals and verifications from patch set 3.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Change-Id: I49d3af4f26e0e0948cf36e867d99c921ee106b2d

Gingerbread Camcorder : Support for H.264 Encoder

Description : Adds support for H.264 encoder.

Signed Off By : Sreenidhi Koti <Sreenidhi@ti.com>

Patch Set 5: Rebasing to break dependency chain. Cherry-picked
on current tree. No changes made. Taking verifications and
approvals from patch set 4.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Ic2e811ac32ceadc2ae34dc7a9dc75c462df8a77c

Encoder-H264 : Support for B-Frames

This patch enables inclusion of B-Frames in H264 Encoded Video.

Signed-off-by : Kalpesh Patil <kalpeshpatil@ti.com>

Patch set 3: Simple cherry-pick to break dependency on non-existent
patch. No changes made. Taking approvals and verifications fom
patch set 2.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I020e5d45febe2830e7a72536043267db051be2c0

Stagefright: OMAP4 output buffer count from codec - bug fix.

minimum no of buffers required on a port is communicated by codec via video.portdef.nBufferCountMin
actual no. of buffers allocated on a port is communicated to codec via def.nBufferCountActual parameter.

Today def.nBufferCountActual is used to set buffer count which is not intended and causing high buffer count usage

Signed-off-by: Devaraj Rangasamy <dev@ti.com>

Patch Set 2: Simple cherry-pick on current tree. No changes made.
Taking build test, verifications and approvals from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Ib9f57aa981b86408aaf7612f80b3540587d57e7a

Store Stride in the meta data.

Stride is required by flash to perform color conversion.

Note# these changes are ported from Froyo
http://review.omapzoom.org/#change,10713

Signed-off-by: Anu Sundararajan <sanuradha@ti.com>

Patch Set 2: Cherry-pick on current tree. No changes made.
Taking verifications, approvals and build test from patch set
1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I3404dd2f3687f59618d50b7fc297c9d48a6301cb

OMXCodec: Initialize quirk to kRequiresAllocateBufferOnOutputPorts

If the quirk is set to kRequiresAllocateBufferOnOutputPorts by the
OMXCodec Client, then AllocateBuffer is called on the output buffer
else UseBuffer is called. UseBuffer can be called only for Overlay
buffers. Ideally speaking, one should not expect the client to know
these details. They must be handled internally.

In the case of flash playback, it is expected to call
OMXCodec::Create() with the flag kPreferAllocateBufferOnOutputPorts.
This flag is a TI specific flag and hence flash is unaware of it.
Furthermore, it cannot be hardcoded in flash since the enum value
has been changing too.

Patch Set 3: Resolved OMAP3 build issues by making it OMAP4 specific.

Signed-off-by: Anu Sundararajan <sanuradha@ti.com>

Patch Set 4: Simple cherry-pick on current tree. No changes made.
Taking build test, approvals and verifications from patch set 3.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I8ad9697cbaf25d04b0d5e3e394fd2db66b78fe59

Stagefright: Making kRequiresAllocateBufferOnOutputPorts as default quirk breaks NPA thumbnail mode

Changeset1:
- Making kRequiresAllocateBufferOnOutputPorts as default quirk breaks NPA thumbnail mode
Clear it for NPA thumbnail mode

- Break was introduced by http://review.omapzoom.org/11427

Change-Id: I14ba6d98398903a436b306e1e5490f6d83341719
Signed-off-by: Devaraj Rangasamy <dev@ti.com>

OMXCodec changes to handle overlay decided buffer count

The changes are for porting the below patch from Froyo to Gingerbread
----------------------------------------------------------
http://review.omapzoom.org/#change,9211
Description: Currently, the number of buffers required on code output port are
calculated in OMXcodec as well as in TIHardwareRenderer.
And OMXCodec assumes that those many buffers are in deed allocated by overlay.
But in some scenarios it it so possible that, Overlay might get fewer number
of buffers than requested by OMXCodec. In that scenario there will be a
segmentation fault in the system. In order to handle this scenario, OMX codec
is enhanced to reconfigure the codec when it receives the buffers from the
Hardware Renderer (through AwesomePlayer) for the first time.
----------------------------------------------------------

Signed-off-by:<dnk.mohan@ti.com>

Patch Set 3: Cherry-pick on current tree. No changes made. Taking
approvals and verifications from patch set 2.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Ie1642d25eb8f520cb796526882969cb70e751acd

OMAP4: Re-enable Vorbis decoder

MIMETYPE of Vorbis audio decoder contents is missing after
OMAP4 integration, resulting in no OGG sound

Patch Set 2: No changes made. Simple cherry-pick on top of
current tree. Taking verifications and approvals from patch
set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I24a85288ad124c345ef0a9035d18e0d247fc2af3

Stagefright: Added support for 2 new codecs - VP6 and VP7

Description# Modified OMXCodec table to include ducati VP6 and VP7 codecs.
updated decoder caps for the same. And updated ducati specific checks for
VP6 & VP7 as well.

Note# These changes are ported from Froyo

Patch Set 2: Rebased against latest.

Change-Id: I6bd46ed45c862e21e80e2b11166b846881ba4406
Signed-off-by: Sunita Nadampalli <sunitan@ti.com>
Signed-off-by: Anu Sundararajan <sanuradha@ti.com>

Stagefright: Enable support for dynamic port -reconfiguration while using Ducati IVAHD codecs

Patchset1:
- When codec detects change is width,height of the stream, it raises port reconfig event, port is disabled and enabled.
- For port -reconfiguration during AVPlaybakc usecase, Since new set of overlay buffers are required before re -enabling port, defer port enable for ducati playback usecase till overlay buffers are available.
- ResizeRenderer() should be aware of new output buffer count for new resolution
- For port -reconfiguration during thumbnail usecase or stagefright -t tests, retry will happen in StagefrightMetaDataretriever, while output port will disable and reenable itself with allocated buffers.
- Limitation: NPA mode for thumbnail is not working for now and disabled. will be enabled incrementally

Patchset2:
- Rebased to latest codebase

Signed-off-by: Devaraj Rangasamy <dev@ti.com>

Patch Set 3: Cherry picked on current tree. No changes made. Taking
approvals, build test and verifications from patch set 2.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I1eabf4fb9d060dc5126b443cbe77f687687ec7d9

OMXRenderer changes to propagate display W&H on resizing

Description# OMXRenderer is modified to propagate the display
W&H along with the decoded buffer W&H while resizing the
rendererer. This is required to update the crop window with
Overlay.

Awesomeplayer is modified to query the Video width and height
and provide the same for resize Rendererer call.

DRT#OMAPS00236082 - Multiple robustness test clips are playing with noise
in the right side of screen due to incorrect port reconfig handling
Note#This is one of the multiple patches for this DR
this patch is dependent on
http://review.omapzoom.org/#change,12705

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 3: Simple cherry-pick on current head. Taking approvals,
verification and build test from patch set 2.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Iceadb97202750b08dd45f8749a5337d5c69f0dc5

Surfaceflinger changes for dynamic display change

Description: These changes are ported from Froyo
change details:
(1) custom omap mm library has been added
(2) Surface class is extended for display ID settings and introduced omapmm
lib as a friend class
(3) Layer base and buffer class changes for display setting to the Overlay

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 5: rebased again. Merge conflicts fixed.
Patch Set 6: Patch Set 5 with a comma in include/surfaceflinger/ISurface.h.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: If13257af633958fab57a63a504b17d17c27d2537

SurfaceFlinger changes for Overlay cloning

The changes are for porting the below patch from Froyo to Gingerbread
----------------------------------------------------------
http://review.omapzoom.org/#change,9708

Description# ISurface interface is extended for dynamic overlay cloning.
This includes ISurface binder extension and layer buffer implemetation
to call overlay data context for requesting overlay cloning.
The same interface is used for enabling/disabling the overlay cloning.
Hence based on whether this is enable or disable, the ISurface interface
handles duping the fd for the cloned video device.

----------------------------------------------------------
Signed-off-by:<dnk.mohan@ti.com>

Patch Set 2: No change made. Simple cherry-pick on current tree.
Taking verfications and approvals from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Ie1df963238ffa83181b36fd1cb92b9aa5ce020ce

Changes made to OMXCodec.h so that a derived class can be created.

Minor changes made to the class definition so that we can create a TIOMXCodec that is derived from OMXCodec.
In future, all changes to OMXCodec should be made in TIOMXCodec, instead.
AwesomePlayer also needs to be modified to use TIOMXCodec instead of OMXCodec.

This is necessary in order to maintain compatibility for flash playback.
Note# these changes are ported from Froyo
http://review.omapzoom.org/#change,9014

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch set 2: Simple cherry-pick. No changes made. Taking
approvals, build test and verifications from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Id687b5b2e84c71f1aab71276d5c0ae16770431c2

Stagefright: Re-enable NPA mode for thumbnail generation, which was disabled for port reconfiguration changes

Changeset1:
- Our Stagefright NPA statemachine has to be reset when PortReconfig is triggered,
so as to go ahead with post port-config sequence

- For 1D output buffer usecases, port config should result in nStride update as nFrameWidth will be new.
No chagne for 2D output buffers, since constant 4K stride is used

Changeset2:

- Rebased

Signed-off-by: Devaraj Rangasamy <dev@ti.com>

Patch Set 3: Breaking dependency on merge commit. No changes made.
Taking approvals and verifications from patch set 2.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Ic421140a892384b8c30a9e59e2d5076b1bd8fa65

Gingerbread : Including TI Index header files & removing duplicate codes

Description : Removing duplicate codes by including TI index header files.

Signed Off By : Sreenidhi Koti <sreenidhi@ti.com>

Patch Set 5: Cherry-picking on current tree to break the dependency on
patch 9556. Taking approvals and verification from patch set 4.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Change-Id: I9063c273426fb1987c9c20d04af6f10633140b20

FM Rx: Added FM framework support

This patch is rework of patch 6235 (cd38325421b73ae5693b1f9991aeeb5b982154c8) on p-froyo for FM Rx
changes. The audio flinger directory is changed in gingerbread. Resubmitting the patch for FM Rx in
gingerbread. All the changes are in OMAP_ENHANCMENT flag

Description: FM Support: Added the FM support in the framework for enabling FM.

Change-Id: I1ff2f6484c673522f83659d9696aba6a2060a798

Defined the DEVICE_OUT_FM_TRANSMIT for FM Tx device in Android Framework

cherry picked from p-froyo commit-id b820e1009d4c619c254ef6cfaa58cf48182b4e3f

Signed-off-by: Shitiz Kumar <shitiz_kumar@ti.com>

Patch Set 2: Cherry pick onto current head. No changes made.
Taking verification and approvals from previous patch set.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: If8c05732954fd7b2c7ca908504a9e27820b115c5

add support for Low Power and DMIC

AudioService registers for intents from applications
that notify of mic selections, and changes in power mode.

For now, mic choice will be determined by system property only.

For changes in power mode, AudioService will set the connection
state of a new DEVICE_OUT_LOW_POWER and trigger policy manager to
route to the low power hw device.

Signed-off-by: Chris Kelly <c-kelly@ti.com>

Patch Set 2: Removed whitespace error. No significant changes made.
Taking approvals and verifications from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Change-Id: I9085217d76d5e897c855df31d397a604649ef04c

AudioSystem: voice call record: new channel CHANNEL_IN_VOICE_UPLINK_DNLINK

Voice call record is started by selecting inputsource
AUDIO_SOURCE_VOICE_UPLINK or AUDIO_SOURCE_VOICE_DOWNLINK
or AUDIO_SOURCE_VOICE_CALL.
For inputsource AUDIO_SOURCE_VOICE_UPLINK and
AUDIO_SOURCE_VOICE_DOWNLINK, there's only 1 dedicated input channel
that permits to start record in mono.
But for inputsource AUDIO_SOURCE_VOICE_CALL, there's no dedicated
channel so the channel CHANNEL_IN_VOICE_UPLINK and
CHANNEL_IN_VOICE_DNLINK are enable.
Therefore the record is done in stereo.
To avoid that and be inline with a voice call record uplink only
or downlink only a new input channels is created.

Change-Id: I6f1d383e185b51d4798db8e62f9310a52ad8da7c

Add a java OMAP_ENHANCEMENT property definition

Cherry picked from 3f812d8daf3ffa685104083abeb7fcb30056baf1

Change-Id: I439fc98cbb38e07044d568444ed9a729a0172e81

OMXCodec changes to overload constructor for OMXNode Id

The changes are for porting the below patch from Froyo to Gingerbread
----------------------------------------------------------
http://review.omapzoom.org/#change,10897
Description# OMXCodec create function is overloaded to provide OMXNode Id
handle back. The node Id is used by the Awesomeplayer for configuring the
codec directly.
This patch is only addition of the overloaded method, but the method is
not being used at this point.
----------------------------------------------------------
Patchset2: Fixed build error for OMAP3

Change-Id: I52fb78486048f66e00608e08d31bd20b32f2c178
Signed-off-by:<dnk.mohan@ti.com>

GingerBread Camcorder : Support for padded width & padded height.

Adds support for padded width & padded height in Stagefright AV-Record path.

Patchset-3 makes correction in width & height used for SetParameter for
OMX_TI_IndexParam2DBufferAllocDimension.

Signed Off By : Sreenidhi Koti <sreenidhi@ti.com>

Change-Id: I60aa6a5caf01218d6650eea2f090427a16b46d02

Stagefright fix: Low resolution clips crash with ducati codec

The changes are for porting the below patch from Froyo to Gingerbread
----------------------------------------------------------
http://review.omapzoom.org/#change,9651

- MediaBuffer mSize should used video padded height, rather than original video height,
since output buffer size will have padded width and height.

Break should've introduced when Android video proxy is updated to remove 2D buffer support.
----------------------------------------------------------

Signed-off-by:<dnk.mohan@ti.com>

Patch Set 2: Cherry-picked on current head, no changes made.
Taking verifications, approvals and build test from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Change-Id: I142b622a7c4455e7cfe431847001a458a8875599

OMXCodec fix for buffer size calculation.

Description# When the video source meta data is maintained
separately for video frame w&h and buffer w&h, the buffer size should be
calculated from the padded height instead of the Video height.
This was missed out earlier, this patch corrects the buffer size calculation.

Change-Id: Idd46b71e050c2c3759b92330aa91aea52878591b
Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Stagefright: Thumbnail corruption fix on port reconfig

Patchset1:
- On port reconfig, thumbnail driver or any other OMXCodec user should be aware of updated WxH
MediaTrack metadata will have new WxH
OMXCodec MetaData will have padded WxH (this is by default)

- Whitespace changes (remove tabs)

Signed-off-by: Devaraj Rangasamy <dev@ti.com>

Patch Set 2: Simple cherry-pick on current tree. No changes made.
Taking approvals and verifications from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Ibeb7935307c49492e482dc74d779a69300e4b620

Stagefright changes to maintain buffer padded W&H along with Video W&H

Description# Stagefright OMXCodec and AwesomePlayer are modified to
store and use the padded width and height for the output buffers.
This is required to handle port reconfiguration scenarios where in,
both video dimensions and buffer dimensions are required. Earlier the OMXCodec
metadata was always holding the padded width and height, hence there was
no way to communicate the video dimensions to Awesomeplayer.

DRT#OMAPS00236082 - Multiple robustness test clips are playing with noise
in the right side of screen due to incorrect port reconfig handling
Note#This is one of the multiple patches for this DR

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 3: Simple cherry-pick on current head. Taking approvals,
verfication and build test from patch set 2.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I441c95dece8b126794f749759d6b6fc651f27094

Moving Input buffer of video decoder to usebuffer call

Currently we are using allocate buffer call for input buffer.
These buffers are 1D tiler buffers and allocated by DOMX.
We see improvement in memcopy if we ask omx il to allocate buffer
and pass it to the component. THis improvement in copy time is
due to cache attributes. So we have moved to use buffer than
allocate buffer. This was also recomended by PSI team

Defect ID: OMAPS00229223

Change-Id: Ib2d355417e479fe2be76c3d5ce5e127158fcf482
Signed-off-by: Dandawate Saket <dsaket@ti.com>

Resolved VP6/7 playback issues

New extended OMX parameters must be set for VP6/7
depending on the type of stream.

Note# these changes are ported from Froyo
http://review.omapzoom.org/#change,9653

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch set 2: Cherry-pick on current tree. No changes made.
Taking verifications, and approvals from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Iee8d579bfc4dd7e93cb08275a89e2514aef05e32

Add support for ASF parser in Stagefright

This patch adds the changes needed to support the ASF parser which is needed for playing
WMV and WMA clips. This patch does not contain the parser itself but it makes the parser
runtime-discoverable.

Change-Id: I72bad81bbdecc5293b0528b593d9cd3df4f65815

VideoView changes to handle Dynamic display changes

Description: This patch includes changes in the VideoView widget to
load the custom java/jni, and send dynamic display change events to the JNI.

Note# these changes are ported from Froyo branch

Change-Id: I95f9ca064375985501cebf1ef228a1ed4e18d36f
Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

VideoView changes to enable Video cloning on HDTV and LCD

Description# Video view is modified to set the mediaplayer with the Omapmmlib.
This mediaplyer instance is used by the Omapmmjni service to enable
video cloning on media player.

Validation# tested aV playback on LCD and HDMI

Change-Id: Ia8fdc3ebb2c002fe07ea9321b831d63a9cc4f862
Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

OmapMMLibrary changes for Video Cloning The changes are for porting the below patch from Froyo to Gingerbread ---------------------------------------------------------- http://review.omapzoom.org/#change,9755

Description#OmapMMlibrary is extended to talk to mediaplayer for
video cloning. Video view is modified to set the mediaplyer instance object
with the omapmm custom library.
----------------------------------------------------------
Patchset2: Removed changes in videoview.java as it will be handled in another patch
to avoid build issues.

Change-Id: Iaa5cfeba74e3884397a4f301b6d5380b8b2f85a7
Signed-off-by:<dnk.mohan@ti.com>

stagefright: Pass offset value of the frame data from camera source to omx codec

When VNF is enabled the data received from camera source provides an offset
value with each frame that has to be passed to the omx codec (ducati) for
proper encoding. In the absence of this there were artifacts seen in the
resulting output. This patch addresses this issue.

Solves DR#OMAPS00233255

Verified sanity on AV record/playback.

Signed-off-by:<dnk.mohan@ti.com>

Patch Set 3: Addressed the formatting issues raised by Dan.
Taking approvals and verifications from patch set 2 since no
code was fundamentally changed.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I2081c1038195671843d83977d8940af1914731f1

Framebuffer: Support variable number of framebuffers in the UI

This change defines a macro NUM_FRAME_BUFFERS to set
the desired number of framebuffers to be used by the UI,
instead of hard-coding 2 framebuffers.

Aditional logic was added to handle the initialization and destruction
of NUM_FRAME_BUFFERS buffers.

Ported from FroYo

Change-Id: I86c707d6deaae61ef72e5e48ae91437b2472977a
Signed-off-by: Rodrigo Obregon <robregon@ti.com>

Native window support for any FB.

This patch allows clients of the class FrameBufferNativeWindow
to be able to create a native window surface on any display.

Change-Id: I8902858be85b83b287b8d9944bc80c82e7c34e1f
Signed-off-by: Rodrigo Obregon <robregon@ti.com>

OverlayRenderer: A new class for accessing Overlay

Since only the mediaserver process has the necessary permissions
to create a surface and to create an overlay, we need this new class
for the flash plugin to make use of overlay.
Note# these changes are ported from Froyo
http://review.omapzoom.org/#change,9245

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

IOMX: implement getBuffer() call for IOMX interface, so as exteral application use own player driver

The changes are for porting the below patch from Froyo to Gingerbread
----------------------------------------------------------
http://review.omapzoom.org/#change,10692
if External applicaiton creates a player driver(awesomeplayer), then H/W renderer is
created by MediaServer if the AwesomePlayer, which is created by external-application
wants to send buffers to the H/W Renderer, it have to send by Binder calls.
This patch implements getBuffer Binder interface between H/W Renderer of MediaServer
and AwesomePlayer of external application.
----------------------------------------------------------

Signed-off-by:<dnk.mohan@ti.com>

OMAP4: Enable Stride and Offset Support in Camera Framework

Modify camera and stagefright framework for taking
stide and offset from timestamp callback

Change-Id: I19308cda849bfad3a03dbe7fe070c38ab5bdc5d4

Conflicts:

services/camera/libcameraservice/CameraService.h

OMAP3: SF: Fix the misuse of mLastVideoBuffer in AwesomePlayer

mLastVideoBuffer is not used with OMAP_ENHANCEMENT flag. And,
current code causes a segmentation fault when it tries to access
mLastVideoBuffer which is not initialized at constructor.
This fixes the segmentation fault in suspend function.

Because there's no code for OMAP4, 'if(0) {' routine for OMAP4
was still left unchanged.

Change-Id: Ie2a8abaf3f36a62235be4331956a74737c8aa896
Signed-off-by: keun-o.park <sahara@ti.com>

OmapmmLib changes to fix native surface field

Description# surface class mSurface field id replaced with mNativeSurface.

patchset2: rebased to the latest codebase.

Change-Id: I7bdc8148ea8bf58ce73a62cd6d68e0f44c6cc84e
Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

OMXCodec fix for NPA mode thumbnail scenario

Description# The mNumberOfNPABuffersSent state variable
update is corrected in fillbufferdone callback.
Earlier we were decrementing the state variable in
FillbufferDone callback unconditionally.During port
reconfiguration scenarios we were resetting this variable
to "0" hence the further decrement in FillBufferDone callback
was wrapping around this unsigned state variable to large value.
This was resulting in no buffer sending to Ducati for thumbnail
generation, hence thumbnail generator was hanging forever.

This is fixed by decrementing the mNumberOfNPABuffersSent state
memeber only if it non-zero positive number.

DRT# OMAPS00236210 - No thumbnails generated for the clips which result
in port reconfiguration

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 2: Simple cherry-pick on current head. Taking approvals,
verfication and build test from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Ibaaca788497583ab7d0fadef5cc491c72dfb0486

OMXCodec changes for tearing effect

Description# In the OMXCodec buffer info, a new field has been added to track
the buffers which are with Player. This means the buffer could be in AV sync
logic, or already with DSS for rendering in case of video buffers, or with
Audio HAL incase of Audio buffers. Earlier these buffers are given back
to codec for filling irrespective of whether they are with sink or free.
This is fixed by adding additional state for the buffer to track the
life cycle of the buffer with the sink.

Validation# tested AV playback and AV record.
DRT#OMAPS00234704 - Tearing video frame on display when fastford/rewind
during the video playback

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 2: Simple cherry-pick on current tree. No changes made.
Taking approvals, verification and build test from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I1bcddddfeaf79c624f304b63f0b342625a4d6e33

OMAP4: S3D: OMX component configurations to handle SEI messages for video playback

Description: Reads Codec buffer metadata to reconfigure S3D display driver

- Parse output buffer for SEI MetaData
- Read metadata and configure S3D display driver
upon framelayout changes sent by codec

Note: Patch ported from Froyo
Dependencies: Patches 13385

Change-Id: I1a1afc1159248f98fc199c0aa288366a592f7e89
Signed-off-by: Gilles-Arnaud Bleu-Laine <gilles@ti.com>

Gingerbread Camcorder : Fix for color distortion in Recorded Clip

Encoder needs a NULL buffer pointer to be passed to OMX_UseBuffer() fucntion.
Whereas Decoder needs a valid buffer pointer for the same.
This patch adds an overloaded function definition for useBuffer() with extra argument 'size'.
For Encoders, this size is passed to OMX_UseBuffer() along with NULL buffer pointer.
For Decoders, this size is ignored.
With this patch, decision is taken which argument to pass based on if component is Encoder or Decoder.

Signed-off-by : Kalpesh Patil <kalpeshpatil@ti.com>

Patch Set 4: Simple cherry-pick on current tree. No changes made.
Taking verifications and approvals from patch set 3.
Change-Id: I176881dd632af2f61e9ed6ade02f6d50e1edbc94
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Patch Set 5: fixed compilation issue with OMAP3
changed #ifdef to be omap4 specific in include/media/IOMX.h

OMAP4: Include OMX_TI_IVCommon.h header file to support definition of color format (PackedSemiPlanar_Sequential_TopBottom)

-- Remove the definiton from Stagefright includes files as
it is a TI custom index.

Note: Patch ported from Froyo.
Dependencies:
GITS omx (http://review.omapzoom.org/#change,10685)
omap3 (http://review.omapzoom.org/#change,13389)

Change-Id: Ie45ac17d985a5008c631e5c5d8b49e3a849f5dea
Signed-off-by: Gilles-Arnaud Bleu-Laine <gilles@ti.com>

Avoid deadlock in OMX::freeNode

By making sure OMXCodecObserver does not hold the
last reference of OMXCodec object

Mirroring change in OMXCodecObserver from mirror update. Mutex
is removed from on_message and moved to onMessage function in
OMXCodecObserver. Fixes race condition we see when stopping
video record.

See 6328185b6cc632f85ff640f6e854ab33815ae97f from gingerbread mirror

Change-Id: If5f4c92f06eb56060659547db39341b428da2b9f

Code cleanup to fix some issues introduced in the ASF parser patch

Fixed following issues:
- Removed complete path from a #include
- Removed leftover debug messages
- Fixed indentation
- Fixed whitespace issues

Change-Id: Ia509d62cd1b93509cf6708eebcd44ae0b0808b50

Changes to support repeated PAUSE_RESUME Scenario.

Consider the following scenario:
1. Buffer arrives early, means in function onVideoEvent mVideoBuffer is not set to NULL
2. Pause
3. Resume, play_l is called successfully at this point
4. In function onVideoEvent, mFirstVideoBuffer is not made NULL as mVideoBuffer is not NULL (see point 1)
5. Again Pause
6. Then Resume
7. play_l is called with mFirstVideoBuffer non-NULL
8. play_l fail in CHECK(mFirstVideoBuffer == NULL)

This patch corrects this issue by releasing mFirstVideoBuffer, if it has not been released already in onVideoEvent

Change-Id: Ie9de7c647936aee3c16bf2ab0ea4cb7bae3cae04

Stagefright: Awesome player and OMXCodec changes to fix some types of port reconfig

Port reconfig is supported as of now. But it does not support port reconfig
during playback (after playing some frames).
This patch adds changes to appropriately flush the buffers towards OMX component
and the renderer.Also it sends proper free buffer requests to OMX component to
enable proper state transitions in OMX component.

Verified with available port reconfig clips.

Patchset2:
For clips having Port reconfig at the beginning sometimes there was a race
condition on causing failure to start playback. This is addressed by adding a
delay in setbuffers before flushing the buffers with freeBuffersOnPort().

Signed-off-by:<dnk.mohan@ti.com>

Patch Set 3: Simple cherry-pick on current tree; no changes made.
Taking approvals and verification from patch set 2.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I5ef8feb46812f1c34e0398d208cd0336d1bdcfe2

AwesomePlayer changes to handle the render buffer failure scenario

Description# Currently Awesome player local data structures are updated with
the buffers with renderer after the render call returns. This would leave out
a scenario where, the render call fails to successfully queue the buffer
with the DSS. In this scenario the buffer can't be reclaimed as it is not
registered with the Awesomeplayer.
This is fixed by updating the bufferswithrenderer structure before invoking
the render method.

Validation# AV playback suspend/resume on LCD and HDTV
DRT#OMAPS00234816 - Gallery app stop reponding after pressing END CALL key
while playing a video on HDMI
DRT#OMAPS00234810 - PT: PPM: AV Playback on HDMI. Video is not rendered back
to HDMI after suspend/resume; instead is played distorted in the LCD

Change-Id: Ib6ce15c6f87c81eeb67b4eb6316f8801cdddc816
Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

OMAP3: set static buffer count for video output

Due to VRFB buffer limitation, it is needed to limit the buffer count
of output port for OMAP3. This fixes that memcpy is used for video
output.

Signed-off-by: keun-o.park <sahara@ti.com>

Patch set 6: Simple cherry-pick on current tree; no changes made.
Taking approvals, build test and verifications from patch set 5.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I254032d9235e11bc5203560f3de1e8c728f84960

Modified Buffer Allocation logic for Video Decoders

Current logic:

For all video decoder usecases (thumbnail, gallery playback, stagefright tests,
flash playback, etc), call OMX_UseBuffer for output port.

For Non-Overlay usecases, the output buffers are allocated by MemoryDealer.
For Overlay usecases, the output buffers are allocated by Overlay.

This ensures that there is no memcpy even when OMXCodec(browser process) and
OMXNodeInstance(mediaserver process) live in two different process contexts.

Patch Set 2&3: Rebased patch on current tree. Fixed merge conflict.

Change-Id: I94eecfa337f115d268ffd26ad95e93ab388529d5
Signed-off-by: Anu Sundararajan <sanuradha@ti.com>

OMAP3: lib StageFright crashes on end of decoding WMA

WMA Decoder sends stopped signal twice at the end of decoding.
The second signal will cause Stagefright to crash due to invalid
thread state.

Signed-off-by: Steve Schefter <sschefter@ti.com>

Patch Set 3: Simple cherry-pick on current tree. No changes made.
Taking approvals, verifications and build test from previous patch
sets.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I0258d3d7124479bc00f0288604a4c5c6966e26f5

Surfaceflinger changes for overlay integration

Description: These changes are ported from Froyo
Change Details:
(1) LayerBuffer class is modified to route Layer calls to Overlay library

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 4: Cherry-picked on current head of tree. No changes
made. Broke the dependency chain.
Taking verifications and approvals from previous patch sets.

Change-Id: I62bb72f36d2d8f9be34c129337527f7f4742ed64

SurfaceFlinger changes to decide when to enable the color key

The changes are for porting the below patch from Froyo to Gingerbread
----------------------------------------------------------
http://review.omapzoom.org/#change,9443
Description: Since color key and per-pixel alpha need to be enabled exclusively
there should be a mechanism in surface flinger to decide when to enable
color key and when to disable.
a new method has been added to the surface flinger to query the graphic plane
pixel format and then enabl/disable color key accordingly.
----------------------------------------------------------

Change-Id: Id7b08c9bcb1187e9eb90fc31f237b3b66c033f4b
Signed-off-by:<dnk.mohan@ti.com>

Moving Input buffer of video decoder to usebuffer call

Defect ID: OMAPS00229223

Change-Id: I8518c1adf2389028417ee2f041f2aa8b92bb395f
Signed-off-by: Dandawate Saket <dsaket@ti.com>

Both OUT and IN buffers should be 128byte aligned according to DSPBridge requirement.

When decoding H264 video via Flash10 Player, OUTPUT buffers are allocated by Stagefright *OMXCodec.cpp), but they have not been 128byte aligned. And it causes the DSPProcessor MAP failure.
This patch applies 128byte alignment for OUTPUT buffer before allocating the memory by Stagefright.
For INPUT buffers, 128byte aligned size is set by OMX before, so we don't need to re-aligned it by Stagefright again.
For the Gallery usecase, OUTPUT buffers are allocated via Overlay, so we don't need to make a alignment here.

Patch Set 2: Simple cherry-pick on current tree. No changes made. Taking
approvals and verifications from previous patch set.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Ib54eae1fe173f4393643f91e9dd498cfb2a4584d

Reduce memcpy in mpeg4extractor for H264

Currently the file content is read into a source buffer and then
parsered for NAL unit size. Then the start code and nal unit is
dumped in destination buffer provided by application.

The code is optimized to put the data from file directly into
application buffer.

Defect ID: OMAPS00229223

Change-Id: Ie6411145fcd5bc1cac4d0d76efee2cb3c133185d
Signed-off-by: Dandawate Saket <dsaket@ti.com>

MPEG4 Extractor memcpy logic correction

Description# Currently the memcpy logic inside MPEG4Extractor
works fine for mNALLengthSize = 4, but for the clips which have
different mNALLengthSize the logic results in segmentation fault.
The memcpy logic is corrected in this patch.

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 2: No changes made. Taking verifications and approvals
from previous patch set.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I95355367e17df9eeb172f7716ab048880af9af85

OMAP4::S3D: Fix S3D playback of recorded videos

Note: -Add support for multiple SEI types per NAL Unit
to support recorded videos.

-Add OMAP4 flag around SEINALLength initialization

Patch set 3 - fix SEINALLenght init for GB.

Change-Id: I2f9a8561792d08a8b17e17566b8dee56051bc260

Signed-off-by: Gilles-Arnaud Bleu-Laine <gilles@ti.com>

libstagefright: Confine port reconfiguration related changes to Ducati video decoders

The below patches
http://review.omapzoom.org/#change,11472
http://review.omapzoom.org/#change,11485

have port reconfiguration related changes that are relevant to
Ducati video decoders only. For other omx decoders(eg:audio)they are not
applicable and will cause issues at start of decoding.
This patch adds additional checks for this purpose.

Verified AV playback and Thumbnail generation.

Signed-off-by:<dnk.mohan@ti.com>

Patch Set 2: Simple cherry-pick, no changes made. Taking
approvals and verifications from patch set 1. Taking build
test from there too.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I2280dbb2086022fb508e21c214487f111dbd6bdb

Setting mOverlay to 0 after destroying it

This was a fix made on HTC Codebase to resolve some Seg faults.
Hence migrating it from Donut to eclair to froyo.
----------------------------------------------------------

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

LayerBuffer fix for Dynamic Display ID change

Description# HDMI Hotplug support is added by modifying the Layer dpy field
from the omapmmLib. This dpy is modified inside the Layer Source on every
display Change event. In this model, there is corner case possible where in
We initiate the suspend/resume, but abort it immediately. This would trigger
HDMI detach in the kernel and hence the detach event is propagated to LayerB
But by this time if the OverlaySource is already destroyed keeping the Layer
Buffer alive, we miss this Layer dpy update. Hence on immediate resume,
The overlay source would see HDMI as the current dpy and configures overlay
for the same even though HDMI is not yet attached in the kernel.
This would result in Overlay configuration failure and hence no Video on LCD
or TV.
This is fixed by initializing the Layer dpy to 0 while constructing the
Overlay source.

DRT# OMAPS00235635 - PT: HDMI AV Playback: When resuming system, before
unlocking the screen, the notification bar shows the clip playing.
DRT# OMAPS00235626 - HDMI AV Playback suspend/resume: Gallery hang

Change-Id: I73f66dd8049849748cc86cc1ad28e9b68294c1a7
Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

OMAP3: SF: fix build error

This fixes 'frameworks/base/media/libstagefright/AwesomePlayer.cpp:
1368: error: 'MEDIA_MIMETYPE_AUDIO_WMA' was not declared in this
scope' in OMAP3

Change-Id: I13325b54b75ff314a567ef4ab8239322630996ff
Signed-off-by: keun-o.park <sahara@ti.com>

libui: Ensures there isn't an uninitialised function pointer

This patch fix the boot up issue in gingerbread with DDK 1.7.17.4958
for using cancelbuffer.

Change-Id: I21336878b39efa0b804ce232a23eebe09e3cd5c0
Signed-off-by: Eric Luong <x0119002@ti.com>

Camera Framework: Adds support for burst messages

- Burst, Exposure and Temporal
bracketing are being started and run
with just one call to takePicture. The
existing mechanism in CameraService
prevents this by explicitly reseting and
checking the compressed message
type during each dataCallback. The
new burst message type on the other
hand will continue processing burst
frames until the sequence completes.

Signed-off-by: Emilian Peev <epeev@mm-sol.com>

Patch Set 6: Simple cherry-pick on current tree. No changes made.
Taking verifications and approvals.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Change-Id: Ib9bfdeae1e4121b5d09f09001224acd9df3b5b40

OMAP4: Enable Camera on Gingerbread

Modify CameraService to select correct overlay format

Change-Id: I4c90cb9161db0d237649f706430e397a4918a1d3

Enable S3D preview in camera framework

Porting over changes from Froyo to enable
S3D preview.

Change-Id: I47a5ab32072a5b118c8ca8ea239e92aa857e655d

Gingerbread Camcorder : Support for H.263 Encoder

Description : Adds support for H.263 encoder.

Signed Off By : Sreenidhi Koti <Sreenidhi@ti.com>

Patch Set 4: Cherry-picked on current tree. No changes made.
Taking verification and approvals from patch set 3.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Change-Id: Ib0ac27fa493b567279cd4a28b121183ca56a9006

OMAP4: S3D: Add SEI Video Encoding configuration support in Stagefrigth

Description: Get Camcorder encoder settings and configure OMX component
to incorporate SEI messages.

Patch Set 7: Set preset values to userdefined in case of S3D

Change-Id: I2982cb71fc8dfdfef33c3b60a97a1c044e083188
Signed-off-by: Gilles-Arnaud Bleu-Laine <gilles@ti.com>

Removing initial seekTo(0) when playing back camera shutter sound.

This fixes DR OMAPS00236070. After boot, with headset plugged in,
when doing an image capture, the shutter sound would play twice due to
an unnecessary seek from the camera service. The seek in this case is
happening before the AudioPlayer is created, and thus, it gets treated as
a deferred seek, which results in the AudioPlayer not being able to do
a simple end of stream call.

Signed-off-by: Ricky Bhatia <a0866433@ti.com>

Change-Id: I7938657c3ceecc01e09ea14d4e42493e190b8146

OMAP3: Handle NULL pointer exception in RawCallback

Change-Id: Ic3a4ca6d2dd58b864be60d183af16bd9562680bb
Signed-off-by: Julian Shandorov <jshandorov@mm-sol.com>

Gingerbread Camcorder : Setting the correct colour format for recording

Descrition : Using YUV420PackedSemiPlanar color format for recording use-cases.

Signed Off By : Sreenidhi Koti <Sreenidhi@ti.com>

Change-Id: Iea7316ca75cf52d3e06c708f6cff742da52f4010

OMAP3: set UYVY format for YUV422I CameraSource

OMX.TI.Video.encode uses YUV422ILE(Little endian) for encording.
So setting YCbYCr caused the incorrect color issue when decoding
the encoded video clip.

Signed-off-by: keun-o.park <sahara@ti.com>

Patch Set 5: Simple cherry-pick; no changes made. Taking approvals,
verifications and build test from patch set 4.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Iad509f0b4d96ec7f4c87c52765043e8281a79917

Fix for EOS buffer sending in Thumbnail mode

In case of thumbnail we are providing 2 codec config buffers and one data buffer.
The data buffer has EOS flag which triggers the decoding and flushing on the output
port. It was seen that the input buffer also gets an callback. This was causing next
input buffer to be send with EOS which is not desired. We want to send only 1 input
buffer.

Signed-off-by: Dandawate Saket <dsaket@ti.com>

Patch Set 2: Removing whitespace errors.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Patch Set 3: Review comment fix

Patch Set 4: White space removal

Signed-off-by: Dandawate Saket <dsaket@ti.com>

Patch Set 6: Simple cherry-pick. No changes made. Taking
approvals and verifications from pathc set 5.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Ic520417621fd4086061a5d8f4185b3d24155c926

Gingerbread Camcorder : Support for MPEG4 Encoder

Description : Adds support for MPEG4 encoder.

Signed Off By : Sreenidhi Koti <Sreenidhi@ti.com>

Patch set 4: Simple cherry-pick on current tree. No changes
made. Taking verifications and approvals from patch set 3.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Change-Id: I2b8c22c3426511bfe5843668885e45afae716297

stagefright: remove memcpy from mp4 parser to OMX input buffer

For AV playback, mem copy from MP4 parser to OMX is a cost operation,
this patch avoided the intermediate copy from MPEG4Source to OMX I/P
which is currently configured to use Tiler 1D buffers, audio and NAL
fragments/multi-slice mode are not impacted by this optimization.

DR#OMAPS00232517

Signed-off-by: Yong Zhi <y-zhi@ti.com>

Patch Set 5: Simple cherry-pick on current tree. No changes made.
Taking approvals, verifications and build test from patch set 4.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I4716d16f64f164d09f7cb6f45f2f051e6f0add33

MPEG4 parser changes for ctts structure

Description: These changes are ported from Froyo.
Change details:
MPEG4 parser currently doesnt understand the ctts structure. If decode
timestamp is not sample as presentation timestamp then the frames will
be presented to AV sync logic in wrong order.

The mp4 parser mandates to take into account the ctts if the decode &
display timestamps are not same.

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 4: Cherry-picked on current head of tree. No changes
made. Taking verifications and approvals from previous patch sets.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Change-Id: I53c3339f8fcba937ac3ddc13ea6810719703ff23

OMXCodec pause/resume scenario handling

Description# For OMXCodec source, there is a pause state, but
there is no explicit resume state. On resume of Awesomeplayer,
the OMXCodec is resumed on first read call from AwesomePlayer.
During this pause/resume transitions, on few iterations, there
is a starvation of Codec for buffers on the input port, because of previous
EMPTY_BUFFER_DONE call back couldn't initiate buffer to Codec,
because of Pause assertion. This is fixed by initiating the
buffer flow on I/P port in read method if the OMXCodec is resumed
from pause state.

Validation# Tested AV playback pause/resume multiple times.

patchset2# moved input buffer drain logic before filloutput buffer
to avoid deadlock.

Change-Id: Id0e72e346b1c9b50e4118007f01ca4ee0610bf75
Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

SF: removing race condition of setting mOwnedByComponent

This fixes a race condition of setting mOwnedByComponent value.
Without this fix, setting mOwnedByComponent at the return of
fill_buffer() call sometimes lose in the race with FillBufferDone
call which also tries to set mOwnedByComponent.
To avoid the race condition and keep proper meaning of
mOwnedByComponent, mOwnedByComponent line should be placed right
before the fill_buffer() or emtpy_buffer() call.

Signed-off-by: keun-o.park <sahara@ti.com>

Patch set 3: Simple cherry-pick on the current tree. No changes
made. Taking verifications, approvals and build test from patch
set 2.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I49a3fd18f7fac48d53956f8294e302f7362be641

Stagefright: Putting back memcpy from a previous change for OMAP3

This change will put back a memcpy removed by a previous change by
setting the changes to be target specific.

Signed-off-by: Juan Escamilla <juan.escamilla@ti.com>

Patch set 3: Simple cherry-pick on current tree. Taking approvals,
verfication and build test from previous patch set.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Id1a11c4f85482da2eb2e07057b49e96fda6f094a

OMAP3: enable two ITTIAM encoder codecs

This patch enables the two ITTIAM encoder.
OMX.ITTIAM.AAC.encode
OMX.TI.720P.Encoder

Change-Id: I84533191575e7f3be847f5dffb64d7038eb1e7b8
Signed-off-by: keun-o.park <sahara@ti.com>

Camcorder : Support for No Audio feature in MediaRecorder

By default NB-AMR is enabled for No-audio.
This patch prevents setting of Audio Encoder Parameters for No-Audio option.
This patch ports below patch from Froyo to Gingerbread.
http://review.omapzoom.org/#change,5318

Patchset-2 Adds check for SystemProperties.OMAP_ENHANCEMENT

Signed-off-by : Kalpesh Patil <kalpeshpatil@ti.com>

Change-Id: I408c25ba5d758bd222f4e006ee7e3a7de938927b

FM UI framework changes for FM Rx GUI

The changes are done under OMAP_ENHANCEMENT flag for FM+ Multimedia combo use cases.

cherry picked from p-froyo commit-id 541a8145f7994b59b9334d53a0448f0e43a3d4bb

Change-Id: I5c9f0be1257e855dcd3341eae7eaeb9a01b18906
Signed-off-by: Shitiz Kumar <shitiz_kumar@ti.com>

Disable capture message types before stopping preview

If we try to stopPreview in the middle of capture, these
callbacks might occur. In this case, stopPreview will already be
holding mLock while the message handler will try to grab mLock.
Deadlock occurs if the stopPreview and message callback dependencies
are in the same thread.

Issue reproduced with Image Capture/Home Key scenario.

DR: 229853
Patch Set 2: Simple cherry-pick on current tree. No changes made.
Taking approvals, build test and verifications from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I222d00f8bd69c11302a35610095efe0ddc49f876

OMAP3: CameraService: Set timeout to lockIfmessageWanted()

- This prevents from entering into infinite loop often.
One reason for this is when trying to lock the mLock in
CameraService::Client::notifyCallback() and in the same time
CameraService::Client::sendCommand() grabs mLock. In CameraHal we never return
from CameraHal::sendCommand(), because we wait for callback from previewthread,
which is locked in mNotifyCb(), which actually waits infinitely for
mLock.tryLock() in CameraService::Client::lockIfMessageWanted(). So we never
release mLock in CameraHal::sendCommand().

Change-Id: I3d5014a44b47ed0571ffdd062c9671938953fb2c
Signed-off-by: Julian Shandorov <jshandorov@mm-sol.com>

OMAP4: Adding support for 3D images extension (JPS/MPO) for gallery application

Change-Id: I8d3ef643a12c83b3acc1159ac6700e1470b26353
Signed-off-by: Gilles-Arnaud Bleu-Laine <gilles@ti.com>

OMAP4: S3D: Add support for S3D Images extension (JPS/MPO) for Android Framework

Signed-off-by: Gilles-Arnaud Bleu-Laine <gilles@ti.com>

Patch set 5: Simple rebase on current tree. No changes made.
Taking approvals and verification from previous patch set.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Ic430500e9693db116f44e2c630319056323c8e16

OMXCodec::read() to wait indefinitely when executing flash use case.

Issue: Recently, the conditional wait [ mBufferFilled.wait() ] in OMXCodec::read()
was replaced with a timed wait call [ mBufferFilled.waitRelative() ]. This breaks
pause-resume functionality during flash video playback.

Root cause: Flash and Awesome Player handle pause in a different manner.
In the case of AwesomePlayer, when the user pauses the video, AwesomePlayer
implements pause by not calling OMXCodec::read(). Flash implements pause by not
providing any input data. Flash calls OMXCodec::read() even during pause state.
When OMXCodec:: read() times out and returns an error, flash exits the
video_decode thread, resulting in a hang.

Solution: For flash usecases, we are replacing mBufferFilled.waitRelative() with
mBufferFilled.wait(). That is, we will wait indefinitely.

This issue has been discussed with Adobe and they are open to handling this
scenario in a different manner. However, since it is past their code freeze date,
no changes can be made in flash codebase for the WASABI release. Hence we will
put in this temporary fix now and revert/update it later when adobe makes the
necessary changes.

Signed-off-by: Anu Sundararajan <sanuradha@ti.com>

Patch Set 2: Simple cherry-pick on current tree. No changes made.
Takin verifications and approvals from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I461bc8a944a050ab9cd8fcfc28e3e1d5774e3067

Making MPEG4Writer understand out of order streams

Current mp4 writer doesnt understand out of order frames which is caused
due to insertion of BFrames in codecs

B frames is a bidirection frame and is dependent on the next frame to decode
itself

Current issue is the on turning on the B frames in encoder the timestamps
at the output of the encoder gets organized in a pattern.
e.g of 2 b frames
I/p of encoder I B1 B2 P [0 33 66 99]
O/p of encoder I P B1 B2 [0 99 33 66]

So normal decode timestamp is 99 - 0 , 33 - 66 , 66 - 33
Now we will have negative delta for 33 - 66 which will be encoded.

This is going to cause issue when presented to decoder as we will loose
sign anyways. Standard doesnt allow negative delta encoding in stts structure

So we have to sort the timestamps and then make the stts structure.
Then make a ctts structure which will hold the offset from the decode TS

Signed-off-by: Dandawate Saket <dsaket@ti.com>

Patch set 6: Addressed Dan's comments and cherry-picked on current
tree. Taking approvals and verifications from patch set 5.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I1a0eeec83af6cd0e340d29a00bd9f74549eefb90

GB Camcorder : Fix AV-Sync Issue in camcorder

Description : 1) Stagefright recorder spawns two threads to record audio & video tracks independently.

2) Both the threads are scheduled with the standard Linux time-sharing schedule attribute SCHED_OTHER.

3) In the current implementation Audio track thread is created first followed by the video track thread.

4) The audio player is NOT started untill stagefright issues Play() command. This command is called when both
AUdio & Video sources are initialized & their respective threads are ready to run.

5) Since the Audio track thread is initialized before video thread, the dynamic priority of the thread keeps increasing every quantum
it's ready to run but being blocked by the scheduler (As the Audio Player start command is still not issued).

6) Once the Audio player is initialized, the scheduler allows the audio thread to execute for some time quantum
& the audio thread starts reading the data immediatly.

7) At this point Video track is still not started & is blocked to execute by the scheduler.

8) By the time video gets to execute, Audio has already filled approx 512 msec of data (At 128 msec intervals, 8Khz sample rate) . And there is an offset of
half a second.

9) So we will hear the Audio half a second after the video, when Audio & video are played back at the same time.

This patch reverses the creation sequence of Audio & Video, so that video is created first & allowed to execute for few time quantums before audio starts.
Since the update frequency of video TS are fast as compared to audio (33 msec), we will have only few video frames started early when compared to Audio.
This gives perfect AV-Sync when Played back. The actual reason on why Google has cerated Audio before video for REcord needs to be examined.

Defect Id : OMAPS00233256

Verified on AAC & NB-AMR audio codecs with different resolution, Frame rates & all video codecs (H264, H263 & MPEG4).
Verified AV-Sync for short duration (10 secs) & long duration (10 mins)

Signed Off By : Sreenidhi Koti <sreenidhi@ti.com>

Change-Id: I10a64f5c5e202164157b0af8ef245479d2af3388

SF high res/bitrate av streaming support

AwesomePlayer has to wait for 10 sec amount of data being buffered to start playing,
currently NuCachedSource2's kHighWaterThreashold is configured to 5M bytes, this is
less than 10 sec for high bitrate playback duration, so AwesomePlayer is not able to
complete prepare phase, the patch made modification of following parameters:

1. NuCachedSource2/kHighWaterThreshold - sum of max prefetched bytes + gray area,
changed to 13M to buffer 6 - 10 sec duration.
2. NuCachedSouece2/kLowWaterThreshold - threshhold value to trigger prefetch,
changed to 3M, AwesomePlayer will pause if prefeched duration is less than 2 sec
3. AweSomePlayer/kHighWaterMarkUs - cached duration to start playback or seek,
reduced to 6 sec based on 1 and 2, this is also good for seek experience.

Defect: OMAPS00231728

Signed-off-by: Yong Zhi <y-zhi@ti.com>

Patch Set 3: Cherry-picked on current tree. No changes made. Taking
build test, approvals and verification from patch set 2.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: Ide2b7be7e1fffd2c3de1235df2448de993d18b12

libstagefright: fix lock-up condition for av streaming

This fix lock-up condition when AwesomePlayer is waiting for NuCachedSource2 to fill more data
while NuCachedSource2 is above kLowWaterThreshold and enters idle. Also increased kGrayArea,
this value is determined by max video resolution and worst case media layout, 3Mb is about good
enough to handle web oriented clips. This is a re-work of patch #11177 which has mirror update
conflicts.

Change-Id: Ifcd985499e7695f4971e750f3a8c5c5b6fcc8568
Signed-off-by: Yong Zhi <y-zhi@ti.com>

AwesomePlayer enum correction on GingerBread

Description: AwesomePlayer state machine enum is corrected to avoid
conflicts with the default enum values.

Validation# AV Playback from Android Gallery app

Change-Id: I9b292b9d58970a6ce77e6638fa2ede937c554f99
Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Stagefright: Handling playback negative seek scenario

The changes are for porting the below patch from Froyo to Gingerbread
----------------------------------------------------------
http://review.omapzoom.org/#change,5711

This patch has change to fix the issue while performing
the stagefright "b 3" tests. They were failing as negative
offset was calculated and used for seek.

Actually in the SF middleware we have condition to check the
parameters. If the seek value is < 0, then android assert is
triggerred which leads to the issue. Actually as per the test app,
the test has to seek and continue decoding till the EOF.
Hence have modified the seek position handling accordingly.
-----------------------------------------------------------

Change-Id: I0fdd8391f1134b91f7c0c03f635de97fb8b7b2cc
Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

StageFright: Skip zero size chunks in mp4 parser

Some mp4 clips were not playing with error ERROR_MALFORMED
returned from stagefright mp4 parser. These clips had zero
size chunks which the parser was not skipping. The patch
achieves this. I can share the clips if needed.

CSR#OMAPS00234409

Change-Id: Ifd9d99f735b642e8c6c9951bf35a79ec8c995453
Signed-off-by: Srinivas Spurthi G <spurthi.gs@ti.com>

Stagefright parser fix: fixes to play currently failing MP4 files The changes are for porting the below patch from Froyo to Gingerbread ---------------------------------------------------------- http://review.omapzoom.org/#change,10609

- ftypwmf
Few MP4 files have filetype atom as "ftypwmf". Not standard as per www.ftyps.com, but we have test samples with such headers.
Either we accept it like above, or don.t return error if we get valid MOOV or MDAT atoms later.

- mdat check
Few MP4 containes, don.t have filetype atom "ftyp" at all.
Don.t return error ahead, see if we have valid MDAT or other valid atom types. (opencore mp4 parser behavior. Path: opencore/fileformats/mp4)
----------------------------------------------------------

Patchset2# Added OMAP_ENHANCEMENT FLAG
Patchset3# Corrected LOGE macro.

Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Patch Set 4: Cherry-picked on current tree. No changes made.
Taking approvals, verifications and build test.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I058696f93e2429ea99020285c289706c3027b9af

SF: configure kPadding for high-profile AV streaming

During AV seek, if one track's buffer being read first, suppose this
is video, and if the corresponding audio chunk happens to be ahead of
video offset, then there is cache miss, to counter this penalty, kPadding
is used to read 32K bytes adhed of the requested position, adjusted to 768k
to cope better with 720p/1080p.

Signed-off-by: Yong Zhi <y-zhi@ti.com>

Patch set 2: Simple cherry-pick - no changes made. Taking
approvals, verification and build test from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I41de69ff0a81aa7dcf32b4e22f205c3b456232d5

SF: AV streaming bug fix for ERROR_END_OF_STREAM condition

When mFinalStatus is ERROR_END_OF_STREAM, the avail size could still be greater
than the requested size in both single track and multiple track cases, so move
the evaluate and copy block ahead of error checking, this patch also pushed go
google for review (#21967).

DR#OMAPS00234827

Change-Id: I475f15fab844ade2980e67fee6461be25224cc8e
Signed-off-by: Yong Zhi <y-zhi@ti.com>

stagefright: OMXCodec changes to resolve regression in port reconfig

The patch addresses two issues.
1. Due to recent changes to support pause/resume state awareness in OMXCodec
port reconfig funtionality is impacted.
2. There is a race condition occuring some times due to which
we receive multiple times INFO_FORMAT_CHANGED from OMXCodec::read()
leading playback failure.

Verified sanity on AV playback/thumbnail generation

Fixes DR#OMAPS00235166

Change-Id: If9f4421a8ab0b04ef24afc84552df21904616b07
Signed-off-by:<dnk.mohan@ti.com>

720P HW Codec should be used for H264 BP video which H or W is bigger than 864.

Stagefright always select OMX.TI.Video.Decoder for H264 BP video if its resolution
is smaller than 864x480.
But since the supported Width and Height by OMX.TI.Video.Decoder is up tp 864,
we need to use 720P.Video.Decoder for H264 BP Video which resolution is smaller than
864x480 but the Height or Width is bigger than 864.
This patch adds this if-condition.

Ref:OMAPS00243751

Patch Set 2: Simple cherry-pick on current tree. No changes made.
Taking approvals, verifications and build test from previous patch
sets.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: If6637bdd0dd37d6642a5f0f1c3fde3313ad901da

MPEG4 Sniffers fixes for files with only Audio tracks

Description# There are two fixes as part of this patch:
(1) In positionFileAtAtom method we are checking for atom size
to be > 8. But there are few atoms like "free", "wide" etc
which could be of size 8.The comparision is corrected
to >= 8.
(2) And there are few clips which are having only audio traks.
There are no video traks hence the confidence is never changed
to 0.4; this would cause those clips failing to get
detected correctly.

DRT# OMAPS00238282 - MPEG4 sniffer confidence issue

Change-Id: I9cc5da12c35f35fb68ed609c63381de6c43f3f84
Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Stagefright changes to support SoftwareCodecs for thumbnail mode

Description# findMatchingCodecs method in OMXCodec is modified to remove:
the hardcoding of Hardware codecs irrespetive of the quirk.
And capture frame method during thumbnail generation is modified
to remove the unnecessary logic which was forcing the first frame for
thumbnail if it fails during s/w decoding.

DRT# OMAPS00241143-Thumbnails generation of h263,mpg4,h264 of
resolution 32x32 results in media server died

Change-Id: I549edfbb813ea15554a30407f3e07596b41412d4
Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

Gingerbread Camcorder: Fix first I-Frame corruption issue for H264 in GB camcorder

Description : The ducati codec mandatorily returns the first frame as IDR frame after codec config.
GB writer extracts the sequence & picture param set info only from the codec config.
And doesn't expect this info to be present in the consequent I-frame. Since our codec
always sends the first frame as IDR frame, it has extra SPS, PPS & SEI specific
info which GB writer does not understand.

This was causing the GB writer to add these extra info as data & eventually
corrupting the I-frame.

This patch strips off the extra info from the IDR frames so that the parser gets the
info thay way it desires. This patch (along with ducati patch) also fixes the seek issue
for H264 encoder when 4 Motion Vector is enabled. The corresponding ducati patch is:
https://android.dal.design.ti.com/#change,385

Signed Off By : Sreenidhi Koti <sreenidhi@ti.com>

Change-Id: Ibff4060afb3809e6a811dfdcb04d954803ade1cc

Adding support for the 3gpp2 file format

Adding "ftyp3g2" to the Mpeg4FileTypeList to add support for 3gpp2 (.3g2) files
OMAPS00231859

Change-Id: I797e2daf910df38577fa6dfe411edae8f5da1a55
Signed-off-by: Juan Escamilla <juan.escamilla@ti.com>

Stagefright: Add "skm2" into known ftyp types for MPEG4 extractor

In mpeg4extractor ftyp type "skm2" was not there.
Found one customer clip not being played due to this.
Added it to knownFileTypes.

Verified sanity on AV playback and thumbnail generation.

Change-Id: I92994902474be1f44922d5265fbc32ad4b9d598e
Signed-off-by:<dnk.mohan@ti.com>

Stagefright: Add "avc" into known ftyp types for MPEG4 extractor

In mpeg4extractor ftyp type "avc" was not there.
Some of the customer clips are not being played due to this.
Hence added it to knownFileTypes.

Verified sanity on AV playback and thumbnail generation.

Fixes DR#OMAPS00237169

Patchset2: Had further check on availbale ftyp types.
There is no all inclusive list available. But over time
we have covered most of them.Corrected avc to avc1 as there
are no other versions(like avc2, avc3 etc) avialble.
There are two types with iso : isom and iso2.Hence made changed
check for iso.

Change-Id: I4e7919b11ab960aeb5da8ff1c1e15a0e7d1256bd
Signed-off-by:<dnk.mohan@ti.com>

OMAP4: S3D: Restoring SEI message to IDR frames

Note: S3D decoder relies first SEI message on IDR frame
to configure the display driver.

Signed-off-by: Gilles-Arnaud Bleu-Laine <gilles@ti.com>

Patch Set 5: Simple cherry-pick on current tree. No changes made.
Taking verification and approvals from previous patch sets.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I53d9a17c2a17b54e5511ec721c9c44ec5ab2caa8

OMAP3: SF: handling multiple NALs in a output buffer

In case of Ittiam's 720P encoder, it returns the output which has
multiple NALs in itself. And, these multiple NALs has a start code
for each NAL to parse each NAL unit. This patch make MPEG4Writer
be able to handle multiple NALs in a output buffer properly.

Change-Id: I58b285946c4e735cac53aee77c119783536a1942
Signed-off-by: keun-o.park <sahara@ti.com>

Gingerbread Camcorder : Support for H.264 Encoder - High Profile

This patch makes H264-High-profile as default profile for H264 Encoder.
A check was commented in MPEG4Writer which prevents H264-High-profile encoding.

Signed-off-by : Kalpesh Patil <kalpeshpatil@ti.com>

Patch set 2: Simple cherry-pick onto current tree. No changes made.
Taking verifications and approvals from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Patch set 3: Rebase again as previous patch rebased. Taking approvals
and verifications from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>

Change-Id: I5f71dd84cab8e03dbb25687d7bfa0c14c160caf7

OMAP3:SF Fix for 1st frame corruption in MPEG4 encoding.

Discard the buffer after receiving the codec specific data.
Else this will lead to writing of wrong entries into
the stss, stsz & other atoms. Which causes the playback
of first 1 second of clip to be blank on QuickTime.
TI Video encoder and Ittiam Video encoder sends only the codec
specific data in the first buffer now. But, it still doesn't
have the codec specific data flag set yet.

Change-Id: I4174d50d7db6e866c30c0791581dcf81dca98c01
Signed-off-by: Vikram Simha <vikram.simha@ti.com>
Signed-off-by: keun-o.park <sahara@ti.com>

MPEG4 Writer changes to reduce time taken for Stts and Ctts Writes

With Current implementation, in the for loops for entering Stts Entry as
well as Ctts entry, the check for iterator was the List.size() call. This
API is implemented to iterate throught the list and return the size. So when
we iterate through list of size more than 10000 ( around 10 min record ) this
iterator check added significant delay and hence TN generation was taking
close to 1 min for a 10 min Video.

This patch removes the uncessary List.size() and saves the size beforehand
in a local variable.

Fix for DR: OMAPS00241059

Signed-off-by: Sathya Prakash M R <a0393677@ti.com>

Patch Set 2: Simple cherry-pick on current tree. No changes made.
Taking approvals, verifications and build test from patch set 1.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I13d8438024b7841b2590179a8defb228f82b0592

Update Timestamps based on sample counts

For non 1080p clips we are seein that the sample count is
comming to be non zero quite often. This was causing a
drift in timestamp. Added correction in finding difference
in timestamp. This is bug in implementation and was missed.

Change-Id: I3e8e2e5bdb2621217f629d2a017a39c21f1c35d9
Signed-off-by: Dandawate Saket <dsaket@ti.com>

Mpeg4 doesnt meet the PPM target

Mpeg4 ppm clips dont meet the validation criteria of 30fps.
The issue was found to be in ctts structure not added to the
stts structure causing wrong time stamp to be presented to
the decoder. This was done only for H264 and not for mpeg4.

DRT: OMAPS00229150
patchset2: fixed review comments.

Change-Id: I71112f48564ad8f778628bfd59bc11c59fcdce6d
Signed-off-by: Sunita Nadampalli <sunitan@ti.com>

libstagefright: Discard SEI messages after getting the frame packing

we don't recognize anything else, anyway, and some messages confuse
the parser

Change-Id: Ie74f5fa9dc3b50cc7108f4b252faaacf716a4c60

OMAP3: StagefrightRecoder: limit Max-bitrate by H.264 profile level.

When the H.264 recording of Camera is freezed and hanged.
(In case of, set high bitrate to low resolution)
In the CODEC side, codec waiting for corresponding bitrate by profile level.
- Added encoding parameters table.
- find corresponding bitrate by calculated level and limit max-bitrate

Signed-off-by: Min-su.Kim <x0154824@ti.com>

Patch Set 4: Simple cherry-pick on current tree. No changes made.
Taking verifications and approvals from previous patch sets. Build
test done in patch set 3.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I704cbe858e8498f41497a48a0c54428da9613a01

OMAP: Configuring sample rate appropriatetly for AMR-WB record

StagefrightRecorder was setting the sample rate incorrectly for
AMR-WB speech codec. This change will configure this setting
accordingly.

Change-Id: Ibef47106b84a026719edcc001cfe75ddbeeff4c7
Signed-off-by: Juan Escamilla <juan.escamilla@ti.com>
Signed-off-by: Ricky Bhatia <a0866433@ti.com>

OMAP3: Support FW3A libcamera blobs

FW3A libcameras support a number of extended parameters, but do
not respect the standard API.
camera-omap3 includes support for fw3a, but it requires a set of headers
and libraries that aren't publicly available, so use
BOARD_HAS_OMAP3_FW3A_LIBCAMERA to enable the blob

Change-Id: Ic6e6b88576a538e015ae77eb1fd9fe9ea186a3c4

StageFright: Support for Ittiam AAC encode

This patch is used to enable Ittiam AAC encode at SF level
patch set 3- remove commented out code for wbamr encoder

Signed-off-by: Richard Gong <rgong@ti.com>

Patch Set 4: Simple cherry-pick on current tree. No changes made.
Taking approvals, verification and build test from patch set 3.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I5c8cddee193f69d2e69530c05b8b9e6456419738

OMAP3: SF: Fix wrong condition check for WMV decoder

This fixes the wrong condition check in the OMXCodec.
And, this makes SF select proper codec by a resolution size.

Signed-off-by: Sumukh HS <sumukh.hs@ittiam.com>
Signed-off-by: keun-o.park <sahara@ti.com>

Patch set 4: Simple cherry-pick on current tree. No changes made.
Taking verifications, approvals and build test from previous
patch sets.
Signed-off-by: Jean Johnson <jean-johnson@ti.com>
Change-Id: I7b5786b15dadae06a8241dcf0d02a9fb4d2f053b

OMAP3: Allow a device to set its own number of overlay buffers

This uses the same build-time variable as the corresponding liboverlay
change

Change-Id: Ia477f7ac3901ca64e7af46a7b6ac004b64f33c95

Change-Id: Iedba0187175e333d69d3348d2917c40fbf6a5d27

commit 1a6862fda91d5bc0987d32ab3410a32badcb861e 1 parent 8d9994ab18

rmcc authored July 18, 2011

Showing 122 changed files with 9,593 additions and 170 deletions.

M	core/java/android/hardware/Camera.java	4 ••••
M	core/java/android/os/SystemProperties.java	1 •
M	core/java/android/widget/VideoView.java	105 ••••
M	core/jni/android_hardware_Camera.cpp	10 ••••
M	include/camera/Camera.h	17 •••••
M	include/camera/CameraHardwareInterface.h	11 ••••
M	include/camera/ICameraClient.h	5 •••••
M	include/media/AudioSystem.h	24 ••••
M	include/media/IAudioFlinger.h	7 ••••
M	include/media/IMediaPlayer.h	3 •••
M	include/media/IMediaPlayerService.h	6 •••••
M	include/media/IOMX.h	38 •••••
M	include/media/MediaPlayerInterface.h	4 ••••
M	include/media/MediaProfiles.h	4 ••••
A	include/media/OverlayRenderer.h	127 •••••
M	include/media/mediaplayer.h	3 •••
M	include/media/mediarecorder.h	5 •••••
M	include/media/stagefright/AudioPlayer.h	8 ••••
M	include/media/stagefright/CameraSource.h	9 •••••
M	include/media/stagefright/ColorConverter.h	16 •••••
M	include/media/stagefright/HardwareAPI.h	18 •••••
M	include/media/stagefright/MediaDefs.h	15 •••••
M	include/media/stagefright/MediaErrors.h	3 •••
M	include/media/stagefright/MediaExtractor.h	16 ••••
M	include/media/stagefright/MediaSource.h	20 •••••
M	include/media/stagefright/MetaData.h	19 •••••
M	include/media/stagefright/OMXCodec.h	109 ••••
M	include/media/stagefright/Utils.h	38 •••••
M	include/media/stagefright/VideoRenderer.h	23 •••••
M	include/media/stagefright/openmax/OMX_Index.h	1 •
M	include/surfaceflinger/ISurface.h	12 •••••
M	include/surfaceflinger/Surface.h	12 ••••
M	include/ui/FramebufferNativeWindow.h	19 ••••
M	include/ui/Overlay.h	3 •••
M	libs/camera/Camera.cpp	9 •••••
M	libs/camera/ICameraClient.cpp	17 •••••
M	libs/surfaceflinger_client/ISurface.cpp	70 •••••
M	libs/ui/FramebufferNativeWindow.cpp	147 ••••
M	libs/ui/Overlay.cpp	8 •••••
M	media/java/android/media/AudioService.java	91 •••••
M	media/java/android/media/AudioSystem.java	4 ••••
M	media/java/android/media/DecoderCapabilities.java	2 ••
M	media/java/android/media/MediaFile.java	67 ••••
M	media/java/android/media/MediaRecorder.java	24 ••••
M	media/java/android/media/MediaScanner.java	5 •••••
M	media/java/android/media/ThumbnailUtils.java	5 •••••
M	media/libmedia/Android.mk	8 •••••
M	media/libmedia/IAudioFlinger.cpp	22 ••••
M	media/libmedia/IMediaPlayer.cpp	23 ••••
M	media/libmedia/IMediaPlayerService.cpp	27 ••••
M	media/libmedia/IOMX.cpp	142 ••••
M	media/libmedia/MediaProfiles.cpp	4 ••••
A	media/libmedia/OverlayRenderer.cpp	608 •••••
M	media/libmedia/mediaplayer.cpp	12 •••••
M	media/libmediaplayerservice/Android.mk	8 •••••
M	media/libmediaplayerservice/MediaPlayerService.cpp	40 ••••
M	media/libmediaplayerservice/MediaPlayerService.h	13 ••••
M	media/libmediaplayerservice/StagefrightPlayer.cpp	6 •••••
M	media/libmediaplayerservice/StagefrightPlayer.h	3 •••
M	media/libmediaplayerservice/StagefrightRecorder.cpp	140 ••••
A	media/libstagefright/ASFExtractor.cpp	179 •••••
M	media/libstagefright/Android.mk	31 ••••
M	media/libstagefright/AudioPlayer.cpp	72 ••••
M	media/libstagefright/AwesomePlayer.cpp	756 ••••
M	media/libstagefright/CameraSource.cpp	126 ••••
M	media/libstagefright/DataSource.cpp	9 •••••
M	media/libstagefright/MPEG4Extractor.cpp	703 ••••
M	media/libstagefright/MPEG4Writer.cpp	325 •••••
M	media/libstagefright/MediaBuffer.cpp	15 •••••
M	media/libstagefright/MediaDefs.cpp	15 •••••
M	media/libstagefright/MediaExtractor.cpp	14 •••••
M	media/libstagefright/MediaSource.cpp	13 •••••
M	media/libstagefright/NuCachedSource2.cpp	19 ••••
M	media/libstagefright/OMXCodec.cpp	1,872 ••••
M	media/libstagefright/SampleTable.cpp	69 •••••
M	media/libstagefright/StagefrightMediaScanner.cpp	3 •••
M	media/libstagefright/StagefrightMetadataRetriever.cpp	113 •••••
A	media/libstagefright/TISEIMessagesParser.cpp	560 •••••
A	media/libstagefright/TIVideoConfigParser.cpp	596 •••••
M	media/libstagefright/WAVExtractor.cpp	18 ••••
M	media/libstagefright/codecs/mp3dec/Android.mk	5 •••••
M	media/libstagefright/colorconversion/Android.mk	8 •••••
M	media/libstagefright/colorconversion/ColorConverter.cpp	111 ••••
M	media/libstagefright/colorconversion/SoftwareRenderer.cpp	8 •••••
M	media/libstagefright/id3/Android.mk	3 •••
A	media/libstagefright/include/ASFExtractor.h	93 •••••
M	media/libstagefright/include/AwesomePlayer.h	54 ••••
M	media/libstagefright/include/NuCachedSource2.h	5 •••••
M	media/libstagefright/include/OMX.h	16 •••••
M	media/libstagefright/include/OMXNodeInstance.h	6 •••••
M	media/libstagefright/include/SampleTable.h	14 ••••
M	media/libstagefright/include/SoftwareRenderer.h	5 •••••
A	media/libstagefright/include/TISEIMessagesParser.h	88 •••••
M	media/libstagefright/omx/OMX.cpp	133 •••••
M	media/libstagefright/omx/OMXNodeInstance.cpp	32 ••••
M	media/libstagefright/omx/OMXRenderer.h	8 •••••
A	omapmmlib/Android.mk	44 •••••
A	omapmmlib/com.ti.omap.omap_mm_library.xml	5 •••••
A	omapmmlib/java/com/ti/omap/omap_mm_library/OmapMMLibrary.java	65 •••••
A	omapmmlib/java/com/ti/omap/omap_mm_library/UiCloningService.java	71 •••••
A	omapmmlib/jni/Android.mk	61 •••••
A	omapmmlib/jni/OmapMMLibrary.cpp	309 •••••
A	omapmmlib/jni/UiCloningService.cpp	203 •••••
M	services/audioflinger/AudioFlinger.cpp	47 ••••
M	services/audioflinger/AudioFlinger.h	13 ••••
M	services/audioflinger/AudioPolicyService.cpp	16 ••••
M	services/audioflinger/AudioPolicyService.h	7 ••••
M	services/camera/libcameraservice/Android.mk	8 •••••
M	services/camera/libcameraservice/CameraService.cpp	225 ••••
M	services/camera/libcameraservice/CameraService.h	31 •••••
M	services/camera/tests/CameraServiceTest/CameraServiceTest.cpp	27 •••••
M	services/java/com/android/server/NotificationManagerService.java	28 •••••
M	services/java/com/android/server/NotificationPlayer.java	16 •••••
M	services/sensorservice/Android.mk	5 •••••
M	services/sensorservice/SensorDevice.cpp	9 •••••
M	services/surfaceflinger/Android.mk	2 ••
M	services/surfaceflinger/LayerBase.cpp	20 •••••
M	services/surfaceflinger/LayerBase.h	7 ••••
M	services/surfaceflinger/LayerBuffer.cpp	188 •••••
M	services/surfaceflinger/LayerBuffer.h	27 ••••
M	services/surfaceflinger/SurfaceFlinger.cpp	9 •••••
M	services/surfaceflinger/SurfaceFlinger.h	3 •••

core/java/android/hardware/Camera.java

show inline notes
View file @ 1a6862f

            
                    @@ -2763,6 +2763,10 @@ public class Camera {

                                     /* Support NV cams */

                                     KEY_ISO_MODE = "nv-picture-iso";

                                     str = get(KEY_ISO_MODE + SUPPORTED_VALUES_SUFFIX);

                    +            } else if (str == null && get("iso-mode-values") != null) {

                    +                /* Support OMAP cams */

                    +                KEY_ISO_MODE = "iso-mode";

                    +                str = get(KEY_ISO_MODE + SUPPORTED_VALUES_SUFFIX);

                                 }

                                 return split(str);

                             }

core/java/android/os/SystemProperties.java

show inline notes
View file @ 1a6862f

            
                    @@ -28,6 +28,7 @@ public class SystemProperties

                     {

                         public static final int PROP_NAME_MAX = 31;

                         public static final int PROP_VALUE_MAX = 91;

                    +    public static final boolean OMAP_ENHANCEMENT = native_get_boolean("com.ti.omap_enhancement", false);

                         private static native String native_get(String key);

                         private static native String native_get(String key, String def);

core/java/android/widget/VideoView.java

show inline notes
View file @ 1a6862f

            
                    @@ -35,10 +35,20 @@ import android.view.SurfaceHolder;

                     import android.view.SurfaceView;

                     import android.view.View;

                     import android.widget.MediaController.MediaPlayerControl;

                    +import android.content.BroadcastReceiver;

                    +import android.content.IntentFilter;

                    +import android.os.SystemProperties;

                     import java.io.IOException;

                     import java.util.Map;

                    +/* TI custom package */

                    +import com.ti.omap.omap_mm_library.OmapMMLibrary;

                    +

                    +/* TI FM UI port -start */

                    +import android.os.SystemProperties;

                    +/* TI FM UI port -stop */

                    +

                     /**

                      * Displays a video file.  The VideoView class

                      * can load images from various sources (such as resources or content

                    @@ -48,6 +58,10 @@ import java.util.Map;

                      */

                     public class VideoView extends SurfaceView implements MediaPlayerControl {

                         private String TAG = "VideoView";

                    +

                    +    private OmapMMLibrary mOmapMMHandle = null;

                    +    private IntentFilter mHdmiIntent = null;

                    +

                         // settable by the client

                         private Uri         mUri;

                         private Map<String, String> mHeaders;

                    @@ -65,6 +79,12 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {

                         private static final int STATE_RESUME             = 7;

                         private static final int STATE_SUSPEND_UNSUPPORTED = 8;

                    +    // All possible Display Types on OMAP4.

                    +    private static final int DISPLAY_TYPE_LCD_PRIMARY   = 0x0000;

                    +    private static final int DISPLAY_TYPE_LCD_SECONDARY = 0x0001;

                    +    private static final int DISPLAY_TYPE_HDMI_TV       = 0x0002;

                    +    private static final int DISPLAY_TYPE_PICO_DLP      = 0x0003;

                    +

                         // mCurrentState is a VideoView object's current state.

                         // mTargetState is the state that a method caller intends to reach.

                         // For instance, regardless the VideoView object's current state,

                    @@ -91,6 +111,10 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {

                         private boolean     mCanSeekForward;

                         private int         mStateWhenSuspended;  //state before calling suspend()

                    +    private static final String ACTION_HDMI_PLUG = "android.intent.action.HDMI_PLUG";

                    +    // Broadcast receiver for device connections intent broadcasts

                    +    private final BroadcastReceiver mReceiver = new VideoPlaybackBroadcastReceiver();

                    +

                         public VideoView(Context context) {

                             super(context);

                             initVideoView();

                    @@ -167,6 +191,14 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {

                             requestFocus();

                             mCurrentState = STATE_IDLE;

                             mTargetState  = STATE_IDLE;

                    +

                    +        if(SystemProperties.OMAP_ENHANCEMENT) {

                    +            mOmapMMHandle = new OmapMMLibrary();

                    +            //if the OmapMMHandle is non-null, initialise jni

                    +            if (mOmapMMHandle != null) {

                    +                mOmapMMHandle.native_init();

                    +            }

                    +        }

                         }

                         public void setVideoPath(String path) {

                    @@ -197,6 +229,19 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {

                                 mCurrentState = STATE_IDLE;

                                 mTargetState  = STATE_IDLE;

                             }

                    +

                    +        // Unregister for device HDMI-Hotplug intent broadcasts.

                    +        if(SystemProperties.OMAP_ENHANCEMENT) {

                    +            //unregister and delete the memory for hdmi intent

                    +            if (mHdmiIntent != null) {

                    +                mContext.unregisterReceiver(mReceiver);

                    +                mHdmiIntent = null;

                    +            }

                    +            //delete the omapMMHandle memory

                    +            if (mOmapMMHandle != null) {

                    +                mOmapMMHandle = null;

                    +            }

                    +        }

                         }

                         private void openVideo() {

                    @@ -209,7 +254,14 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {

                             Intent i = new Intent("com.android.music.musicservicecommand");

                             i.putExtra("command", "pause");

                             mContext.sendBroadcast(i);

                    -

                    +        /* TI FM UI port -start */

                    +        if (SystemProperties.OMAP_ENHANCEMENT) {

                    +             // Tell the FM playback service to pause,as the video playback will start.

                    +             // TODO: these constants need to be published somewhere in the framework.

                    +             Intent fm = new Intent("com.ti.server.fmpausecmd");

                    +             mContext.sendBroadcast(fm);

                    +        }

                    +        /* TI FM UI port -stop */

                             // we shouldn't clear the target state, because somebody might have

                             // called start() previously

                             release(false);

                    @@ -231,6 +283,10 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {

                                 // target state that was there before.

                                 mCurrentState = STATE_PREPARING;

                                 attachMediaController();

                    +            if(SystemProperties.OMAP_ENHANCEMENT) {

                    +                mOmapMMHandle.setVideoSurface(mSurfaceHolder);

                    +                mOmapMMHandle.setMediaPlayer(mMediaPlayer);

                    +            }

                             } catch (IOException ex) {

                                 Log.w(TAG, "Unable to open content: " + mUri, ex);

                                 mCurrentState = STATE_ERROR;

                    @@ -278,7 +334,16 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {

                         MediaPlayer.OnPreparedListener mPreparedListener = new MediaPlayer.OnPreparedListener() {

                             public void onPrepared(MediaPlayer mp) {

                                 mCurrentState = STATE_PREPARED;

                    -

                    +            /**

                    +            * Register for device HDMI-Hotplug intent broadcasts.

                    +            * the registration is delayed till the Media player is prepared.

                    +            * This is required to avoid the scenario where the event is disptached

                    +            * even before Overlay source is created.

                    +            */

                    +            if(SystemProperties.OMAP_ENHANCEMENT) {

                    +                mHdmiIntent = new IntentFilter(ACTION_HDMI_PLUG);

                    +                mContext.registerReceiver(mReceiver, mHdmiIntent);

                    +            }

                                 // Get the capabilities of the player for this stream

                                 Metadata data = mp.getMetadata(MediaPlayer.METADATA_ALL,

                                                           MediaPlayer.BYPASS_METADATA_FILTER);

                    @@ -477,6 +542,9 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {

                                 if (mMediaPlayer != null && mCurrentState == STATE_SUSPEND

                                        && mTargetState == STATE_RESUME) {

                                     mMediaPlayer.setDisplay(mSurfaceHolder);

                    +                if(SystemProperties.OMAP_ENHANCEMENT) {

                    +                    mOmapMMHandle.setVideoSurface(mSurfaceHolder);

                    +                 }

                                     resume();

                                 } else {

                                     openVideo();

                    @@ -606,6 +674,12 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {

                                 if (mMediaPlayer.resume()) {

                                     mCurrentState = mStateWhenSuspended;

                                     mTargetState = mStateWhenSuspended;

                    +                if(SystemProperties.OMAP_ENHANCEMENT) {

                    +                    Intent hdmiIntent =  mContext.registerReceiver(null,

                    +                                          new IntentFilter(ACTION_HDMI_PLUG));

                    +                    mReceiver.onReceive(mContext, hdmiIntent);

                    +                }

                    +

                                 } else {

                                     Log.w(TAG, "Unable to resume video");

                                 }

                    @@ -674,4 +748,31 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {

                         public boolean canSeekForward() {

                             return mCanSeekForward;

                         }

                    +

                    +    /**

                    +     * Receiver for HDMI-Hotplug intent broadcasts

                    +     */

                    +    private class VideoPlaybackBroadcastReceiver extends BroadcastReceiver {

                    +        @Override

                    +        public void onReceive(Context context, Intent intent) {

                    +            if (intent == null) {

                    +                Log.e(TAG, "VideoPlaybackBroadcastReceiver intent is NULL!");

                    +                return;

                    +            }

                    +            String action = intent.getAction();

                    +

                    +            if (SystemProperties.OMAP_ENHANCEMENT && action.equals(ACTION_HDMI_PLUG)) {

                    +                int state = intent.getIntExtra("state", 0);

                    +

                    +                if(state==1) {

                    +                    Log.d(TAG, "VideoPlaybackBroadcastReceiver.onReceive() : Switching to HDMI_TV)");

                    +                    mOmapMMHandle.setDisplayId(DISPLAY_TYPE_HDMI_TV);

                    +                } else {

                    +                    Log.d(TAG, "VideoPlaybackBroadcastReceiver.onReceive() : Switching to LCD-Primary");

                    +                    mOmapMMHandle.setDisplayId(DISPLAY_TYPE_LCD_PRIMARY);

                    +                }

                    +            }

                    +        }

                    +    }

                    +

                     }

core/jni/android_hardware_Camera.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -50,7 +50,11 @@ public:

                         ~JNICameraContext() { release(); }

                         virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2);

                         virtual void postData(int32_t msgType, const sp<IMemory>& dataPtr);

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr, uint32_t offset=0, uint32_t stride=0);

                    +#else

                         virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr);

                    +#endif

                         void addCallbackBuffer(JNIEnv *env, jbyteArray cbb);

                         void setCallbackMode(JNIEnv *env, bool installed, bool manualMode);

                         sp<Camera> getCamera() { Mutex::Autolock _l(mLock); return mCamera; }

                    @@ -227,8 +231,12 @@ void JNICameraContext::postData(int32_t msgType, const sp<IMemory>& dataPtr)

                             break;

                         }

                     }

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +void JNICameraContext::postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr,

                    +        uint32_t offset, uint32_t stride)

                    +#else

                     void JNICameraContext::postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr)

                    +#endif

                     {

                         // TODO: plumb up to Java. For now, just drop the timestamp

                         postData(msgType, dataPtr);

include/camera/Camera.h

show inline notes
View file @ 1a6862f

            
                    @@ -78,6 +78,13 @@ enum {

                         CAMERA_MSG_POSTVIEW_FRAME   = 0x040,

                         CAMERA_MSG_RAW_IMAGE        = 0x080,

                         CAMERA_MSG_COMPRESSED_IMAGE = 0x100,

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +

                    +    CAMERA_MSG_BURST_IMAGE      = 0x200,

                    +

                    +#endif

                    +

                         CAMERA_MSG_ALL_MSGS         = 0x1FF

                     };

                    @@ -146,7 +153,12 @@ class CameraListener: virtual public RefBase

                     public:

                         virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2) = 0;

                         virtual void postData(int32_t msgType, const sp<IMemory>& dataPtr) = 0;

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr,

                    +                    uint32_t offset=0, uint32_t stride=0) = 0;

                    +#else

                         virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr) = 0;

                    +#endif

                     };

                     class Camera : public BnCameraClient, public IBinder::DeathRecipient

                    @@ -232,7 +244,12 @@ public:

                         // ICameraClient interface

                         virtual void        notifyCallback(int32_t msgType, int32_t ext, int32_t ext2);

                         virtual void        dataCallback(int32_t msgType, const sp<IMemory>& dataPtr);

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual void        dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr,

                    +                                uint32_t offset=0, uint32_t stride=0);

                    +#else

                         virtual void        dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr);

                    +#endif

                         sp<ICamera>         remote();

include/camera/CameraHardwareInterface.h

show inline notes
View file @ 1a6862f

            
                    @@ -46,12 +46,19 @@ typedef void (*notify_callback)(int32_t msgType,

                     typedef void (*data_callback)(int32_t msgType,

                                                   const sp<IMemory>& dataPtr,

                                                   void* user);

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +typedef void (*data_callback_timestamp)(nsecs_t timestamp,

                    +                                        int32_t msgType,

                    +                                        const sp<IMemory>& dataPtr,

                    +                                        void* user,

                    +                                        uint32_t offset,

                    +                                        uint32_t stride);

                    +#else

                     typedef void (*data_callback_timestamp)(nsecs_t timestamp,

                                                             int32_t msgType,

                                                             const sp<IMemory>& dataPtr,

                                                             void* user);

                    -

                    +#endif

                     /**

                      * CameraHardwareInterface.h defines the interface to the

                      * camera hardware abstraction layer, used for setting and getting

include/camera/ICameraClient.h

show inline notes
View file @ 1a6862f

            
                    @@ -32,7 +32,12 @@ public:

                         virtual void            notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2) = 0;

                         virtual void            dataCallback(int32_t msgType, const sp<IMemory>& data) = 0;

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual void            dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& data,

                    +                                    uint32_t offset=0, uint32_t stride=0) = 0;

                    +#else

                         virtual void            dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& data) = 0;

                    +#endif

                     };

                     // ----------------------------------------------------------------------------

include/media/AudioSystem.h

show inline notes
View file @ 1a6862f

            
                    @@ -145,12 +145,19 @@ public:

                             CHANNEL_IN_Z_AXIS = 0x2000,

                             CHANNEL_IN_VOICE_UPLINK = 0x4000,

                             CHANNEL_IN_VOICE_DNLINK = 0x8000,

                    +#ifdef OMAP_ENHANCEMENT

                    +        CHANNEL_IN_VOICE_UPLINK_DNLINK = 0x10000,

                    +#endif

                             CHANNEL_IN_MONO = CHANNEL_IN_FRONT,

                             CHANNEL_IN_STEREO = (CHANNEL_IN_LEFT | CHANNEL_IN_RIGHT),

                             CHANNEL_IN_ALL = (CHANNEL_IN_LEFT | CHANNEL_IN_RIGHT | CHANNEL_IN_FRONT | CHANNEL_IN_BACK|

                                     CHANNEL_IN_LEFT_PROCESSED | CHANNEL_IN_RIGHT_PROCESSED | CHANNEL_IN_FRONT_PROCESSED | CHANNEL_IN_BACK_PROCESSED|

                                     CHANNEL_IN_PRESSURE | CHANNEL_IN_X_AXIS | CHANNEL_IN_Y_AXIS | CHANNEL_IN_Z_AXIS |

                    -                CHANNEL_IN_VOICE_UPLINK | CHANNEL_IN_VOICE_DNLINK)

                    +#ifdef OMAP_ENHANCEMENT

                    +                CHANNEL_IN_VOICE_UPLINK | CHANNEL_IN_VOICE_DNLINK | CHANNEL_IN_VOICE_UPLINK_DNLINK)

                    +#else

                    +                CHANNEL_IN_VOICE_UPLINK | CHANNEL_IN_VOICE_DNLINK )

                    +#endif

                         };

                         enum audio_mode {

                    @@ -269,12 +276,15 @@ public:

                             DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100,

                             DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200,

                             DEVICE_OUT_AUX_DIGITAL = 0x400,

                    -        DEVICE_OUT_HDMI = 0x2000,

                     #ifdef HAVE_FM_RADIO

                             DEVICE_OUT_FM = 0x800,

                             DEVICE_OUT_FM_SPEAKER = 0x1000,

                             DEVICE_OUT_FM_ALL = (DEVICE_OUT_FM | DEVICE_OUT_FM_SPEAKER),

                    +#elif defined(OMAP_ENHANCEMENT)

                    +        DEVICE_OUT_FM_TRANSMIT = 0x800,

                    +        DEVICE_OUT_LOW_POWER = 0x1000,

                     #endif

                    +        DEVICE_OUT_HDMI = 0x2000,

                             DEVICE_OUT_DEFAULT = 0x8000,

                             DEVICE_OUT_ALL = (DEVICE_OUT_EARPIECE | DEVICE_OUT_SPEAKER | DEVICE_OUT_WIRED_HEADSET |

                     #ifdef HAVE_FM_RADIO

                    @@ -283,7 +293,12 @@ public:

                                     DEVICE_OUT_WIRED_HEADPHONE | DEVICE_OUT_BLUETOOTH_SCO | DEVICE_OUT_BLUETOOTH_SCO_HEADSET |

                     #endif

                                     DEVICE_OUT_BLUETOOTH_SCO_CARKIT | DEVICE_OUT_BLUETOOTH_A2DP | DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |

                    +#ifdef OMAP_ENHANCEMENT

                    +                DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER | DEVICE_OUT_AUX_DIGITAL | DEVICE_OUT_LOW_POWER |

                    +                DEVICE_OUT_FM_TRANSMIT | DEVICE_OUT_DEFAULT),

                    +#else

                                     DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER | DEVICE_OUT_AUX_DIGITAL | DEVICE_OUT_HDMI | DEVICE_OUT_DEFAULT),

                    +#endif

                             DEVICE_OUT_ALL_A2DP = (DEVICE_OUT_BLUETOOTH_A2DP | DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES |

                                     DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER),

                    @@ -300,12 +315,17 @@ public:

                             DEVICE_IN_FM_RX = 0x1000000,

                             DEVICE_IN_FM_RX_A2DP = 0x2000000,

                     #endif

                    +#ifdef OMAP_ENHANCEMENT

                    +        DEVICE_IN_FM_ANALOG = 0x1000000,

                    +#endif

                             DEVICE_IN_DEFAULT = 0x80000000,

                             DEVICE_IN_ALL = (DEVICE_IN_COMMUNICATION | DEVICE_IN_AMBIENT | DEVICE_IN_BUILTIN_MIC |

                                     DEVICE_IN_BLUETOOTH_SCO_HEADSET | DEVICE_IN_WIRED_HEADSET | DEVICE_IN_AUX_DIGITAL |

                     #ifdef HAVE_FM_RADIO

                                     DEVICE_IN_VOICE_CALL | DEVICE_IN_BACK_MIC | DEVICE_IN_FM_RX | DEVICE_IN_FM_RX_A2DP | DEVICE_IN_DEFAULT)

                    +#elif OMAP_ENHANCEMENT

                    +                DEVICE_IN_VOICE_CALL | DEVICE_IN_BACK_MIC  | DEVICE_IN_FM_ANALOG | DEVICE_IN_DEFAULT)

                     #else

                                     DEVICE_IN_VOICE_CALL | DEVICE_IN_BACK_MIC | DEVICE_IN_DEFAULT)

                     #endif

include/media/IAudioFlinger.h

show inline notes
View file @ 1a6862f

            
                    @@ -91,7 +91,12 @@ public:

                          */

                         virtual     status_t    setStreamVolume(int stream, float value, int output) = 0;

                         virtual     status_t    setStreamMute(int stream, bool muted) = 0;

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +    /* This will tell playback thread that FM Rx is active

                    +     * and device will not go to standby

                    +     */

                    +    virtual     status_t    setFMRxActive(bool state)=0;

                    +#endif

                         virtual     float       streamVolume(int stream, int output) const = 0;

                         virtual     bool        streamMute(int stream) const = 0;

include/media/IMediaPlayer.h

show inline notes
View file @ 1a6862f

            
                    @@ -51,6 +51,9 @@ public:

                         virtual status_t        setAuxEffectSendLevel(float level) = 0;

                         virtual status_t        attachAuxEffect(int effectId) = 0;

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual status_t        requestVideoCloneMode(bool enable) = 0;

                    +#endif

                         // Invoke a generic method on the player by using opaque parcels

                         // for the request and reply.

                         // @param request Parcel that must start with the media player

include/media/IMediaPlayerService.h

show inline notes
View file @ 1a6862f

            
                    @@ -32,6 +32,9 @@ namespace android {

                     class IMediaRecorder;

                     class IOMX;

                    +#ifdef OMAP_ENHANCEMENT

                    +class IOverlayRenderer;

                    +#endif

                     class IMediaPlayerService: public IInterface

                     {

                    @@ -48,6 +51,9 @@ public:

                         virtual sp<IMemory>         decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, int* pFormat) = 0;

                         virtual sp<IMemory>         decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, int* pFormat) = 0;

                         virtual sp<IOMX>            getOMX() = 0;

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual sp<IOverlayRenderer>  getOverlayRenderer()=0;

                    +#endif

                     };

                     // ----------------------------------------------------------------------------

include/media/IOMX.h

show inline notes
View file @ 1a6862f

            
                    @@ -137,6 +137,29 @@ public:

                                 size_t encodedWidth, size_t encodedHeight,

                                 size_t displayWidth, size_t displayHeight,

                                 int32_t rotationDegrees);

                    +

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    virtual status_t useBuffer(

                    +            node_id node, OMX_U32 port_index, const sp<IMemory> &params,

                    +            buffer_id *buffer, size_t size) = 0;

                    +#endif

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +    sp<IOMXRenderer> createRenderer(

                    +            const sp<Surface> &surface,

                    +            const char *componentName,

                    +            OMX_COLOR_FORMATTYPE colorFormat,

                    +            size_t encodedWidth, size_t encodedHeight,

                    +            size_t displayWidth, size_t displayHeight, int32_t rotation, int isS3D, int numOfOpBuffers = -1);

                    +

                    +        virtual sp<IOMXRenderer> createRenderer(

                    +            const sp<ISurface> &surface,

                    +            const char *componentName,

                    +            OMX_COLOR_FORMATTYPE colorFormat,

                    +            size_t encodedWidth, size_t encodedHeight,

                    +            size_t displayWidth, size_t displayHeight, int32_t rotation, int isS3D, int numOfOpBuffers = -1) = 0;

                    +

                    +#endif

                     };

                     struct omx_message {

                    @@ -144,7 +167,9 @@ struct omx_message {

                             EVENT,

                             EMPTY_BUFFER_DONE,

                             FILL_BUFFER_DONE,

                    +#ifndef OMAP_ENHANCEMENT

                             REGISTER_BUFFERS

                    +#endif

                         } type;

                    @@ -183,14 +208,27 @@ public:

                         DECLARE_META_INTERFACE(OMXObserver);

                         virtual void onMessage(const omx_message &msg) = 0;

                    +#ifndef OMAP_ENHANCEMENT

                         virtual void registerBuffers(const sp<IMemoryHeap> &mem) = 0;

                    +#endif

                     };

                    +#ifdef OMAP_ENHANCEMENT

                    +typedef void (*release_rendered_buffer_callback)(const sp<IMemory>& mem, void* cookie);

                    +#endif

                    +

                     class IOMXRenderer : public IInterface {

                     public:

                         DECLARE_META_INTERFACE(OMXRenderer);

                         virtual void render(IOMX::buffer_id buffer) = 0;

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual Vector< sp<IMemory> > getBuffers() = 0;

                    +    virtual bool setCallback(release_rendered_buffer_callback cb, void *cookie) = 0;

                    +    virtual void set_s3d_frame_layout(uint32_t s3d_mode, uint32_t s3d_fmt, uint32_t s3d_order, uint32_t s3d_subsampling) =0;

                    +    virtual void resizeRenderer(void* resize_params) = 0;

                    +    virtual void requestRendererClone(bool enable) = 0;

                    +#endif

                     };

                     ////////////////////////////////////////////////////////////////////////////////

include/media/MediaPlayerInterface.h

show inline notes
View file @ 1a6862f

            
                    @@ -122,7 +122,9 @@ public:

                         virtual player_type playerType() = 0;

                         virtual status_t    suspend() { return INVALID_OPERATION; }

                         virtual status_t    resume() { return INVALID_OPERATION; }

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual status_t    requestVideoCloneMode(bool enable) { return INVALID_OPERATION; }

                    +#endif

                         virtual void        setNotifyCallback(void* cookie, notify_callback_f notifyFunc) {

                                                 mCookie = cookie; mNotify = notifyFunc; }

                         // Invoke a generic method on the player by using opaque parcels

include/media/MediaProfiles.h

show inline notes
View file @ 1a6862f

            
                    @@ -32,6 +32,10 @@ enum camcorder_quality {

                     enum video_decoder {

                         VIDEO_DECODER_WMV,

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    VIDEO_DECODER_VP6,

                    +    VIDEO_DECODER_VP7,

                    +#endif

                     };

                     enum audio_decoder {

include/media/OverlayRenderer.h

show inline notes
View file @ 1a6862f

            
                    @@ -0,0 +1,127 @@

                    +/*

                    + * Copyright (C) Texas Instruments - http://www.ti.com/

                    + *

                    + * This library is free software; you can redistribute it and/or

                    + * modify it under the terms of the GNU Lesser General Public

                    + * License as published by the Free Software Foundation; either

                    + * version 2.1 of the License, or (at your option) any later version.

                    + *

                    + *

                    + * This library is distributed in the hope that it will be useful,

                    + * but WITHOUT ANY WARRANTY; without even the implied warranty of

                    + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

                    + * Lesser General Public License for more details.

                    + *

                    + *

                    + * You should have received a copy of the GNU Lesser General Public

                    + * License along with this library; if not, write to the Free Software

                    + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

                    + */

                    +

                    +#ifndef OVERLAY_RENDERER_H_

                    +#define OVERLAY_RENDERER_H_

                    +

                    +#include <utils/Log.h>

                    +#include <OMX_Component.h>

                    +#include <overlay_common.h>

                    +#include <media/stagefright/MediaDebug.h>

                    +

                    +#include <binder/Parcel.h>

                    +#include <binder/IMemory.h>

                    +#include <binder/IInterface.h>

                    +#include <binder/MemoryBase.h>

                    +#include <binder/MemoryHeapBase.h>

                    +

                    +#include <ui/Overlay.h>

                    +#include <surfaceflinger/Surface.h>

                    +#include <surfaceflinger/ISurface.h>

                    +#include <surfaceflinger/ISurfaceComposer.h>

                    +#include <surfaceflinger/SurfaceComposerClient.h>

                    +

                    +namespace android {

                    +

                    +class IOverlayRenderer : public IInterface {

                    +public:

                    +    DECLARE_META_INTERFACE(OverlayRenderer);

                    +    virtual int32_t createOverlayRenderer(uint32_t bufferCount,

                    +                                int32_t displayWidth,

                    +                                int32_t displayHeight,

                    +                                uint32_t colorFormat,

                    +                                int32_t decodedWidth,

                    +                                int32_t decodedHeight,

                    +                                int infoType,

                    +                                void* info)=0;

                    +

                    +    virtual void releaseMe()=0;

                    +    virtual uint32_t getBufferCount()=0;

                    +    virtual sp<IMemory> getBuffer(uint32_t index) = 0;

                    +    virtual int32_t dequeueBuffer(uint32_t *index)=0;

                    +    virtual int32_t queueBuffer(uint32_t index)=0;

                    +    virtual int32_t setPosition(int32_t x, int32_t y)=0;

                    +    virtual int32_t setSize(uint32_t w, uint32_t h)=0;

                    +    virtual int32_t setOrientation(int32_t orientation, uint32_t flags)=0;

                    +    virtual int32_t setCrop(uint32_t x, uint32_t y, uint32_t w, uint32_t h)=0;

                    +};

                    +

                    +

                    +class BnOverlayRenderer : public BnInterface<IOverlayRenderer> {

                    +public:

                    +    virtual status_t onTransact(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags = 0);

                    +};

                    +

                    +

                    +class OverlayRenderer : public BnOverlayRenderer{

                    +

                    +public:

                    +

                    +    OverlayRenderer();

                    +    ~OverlayRenderer();

                    +    int32_t createOverlayRenderer(uint32_t bufferCount,

                    +                                int32_t displayWidth,

                    +                                int32_t displayHeight,

                    +                                uint32_t colorFormat,

                    +                                int32_t decodedWidth,

                    +                                int32_t decodedHeight,

                    +                                int infoType,

                    +                                void* info);

                    +    void releaseMe();

                    +    uint32_t getBufferCount() { return mBufferCount; }

                    +    sp<IMemory> getBuffer(uint32_t index);

                    +    int32_t dequeueBuffer(uint32_t *index);

                    +    int32_t queueBuffer(uint32_t index);

                    +    int32_t setPosition(int32_t x, int32_t y) ;

                    +    int32_t setSize(uint32_t w, uint32_t h) ;

                    +    int32_t setCrop(uint32_t x, uint32_t y, uint32_t w, uint32_t h);

                    +    int32_t setOrientation(int32_t orientation, uint32_t flags);

                    +

                    +private:

                    +

                    +    int32_t createSurface();

                    +    int32_t createBuffers();

                    +

                    +    int32_t mInitCheck;

                    +    int32_t mDisplayWidth, mDisplayHeight;

                    +    int32_t mDecodedWidth, mDecodedHeight;

                    +    uint32_t mColorFormat;

                    +    uint32_t mBufferCount;

                    +    unsigned int mInfoType;

                    +

                    +    /* Surface details */

                    +    sp<Overlay> mOverlay;

                    +    sp<SurfaceComposerClient> mSurfaceClient;

                    +    sp<SurfaceControl> mSurfaceControl;

                    +    sp<ISurface> mISurface;

                    +

                    +    sp<MemoryHeapBase> mVideoHeaps[NUM_OVERLAY_BUFFERS_MAX];

                    +    Vector< sp<IMemory> > mOverlayAddresses;

                    +

                    +    /* copy of previously set window values */

                    +    int32_t win_x;

                    +    int32_t win_y;

                    +

                    +};

                    +

                    +}

                    +

                    +#endif

                    +

include/media/mediaplayer.h

show inline notes
View file @ 1a6862f

            
                    @@ -175,6 +175,9 @@ public:

                                 int             getAudioSessionId();

                                 status_t        setAuxEffectSendLevel(float level);

                                 status_t        attachAuxEffect(int effectId);

                    +#ifdef OMAP_ENHANCEMENT

                    +            status_t        requestVideoCloneMode(bool enable);

                    +#endif

                     private:

                                 void            clear_l();

                                 status_t        seekTo_l(int msec);

include/media/mediarecorder.h

show inline notes
View file @ 1a6862f

            
                    @@ -45,6 +45,10 @@ enum audio_source {

                         AUDIO_SOURCE_CAMCORDER = 5,

                         AUDIO_SOURCE_VOICE_RECOGNITION = 6,

                         AUDIO_SOURCE_VOICE_COMMUNICATION = 7,

                    +#ifdef OMAP_ENHANCEMENT

                    +    AUDIO_SOURCE_FM_ANALOG = 8,

                    +    AUDIO_SOURCE_MAX = AUDIO_SOURCE_FM_ANALOG,

                    +#else

                     #ifdef HAVE_FM_RADIO

                         AUDIO_SOURCE_FM_RX = 8,

                         AUDIO_SOURCE_FM_RX_A2DP = 9,

                    @@ -52,6 +56,7 @@ enum audio_source {

                     #else

                         AUDIO_SOURCE_MAX = AUDIO_SOURCE_VOICE_COMMUNICATION,

                     #endif

                    +#endif

                         AUDIO_SOURCE_LIST_END  // must be last - used to validate audio source type

                     };

include/media/stagefright/AudioPlayer.h

show inline notes
View file @ 1a6862f

            
                    @@ -51,7 +51,9 @@ public:

                         void pause(bool playPendingSamples = false);

                         void resume();

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +    void flush();

                    +#endif

                         // Returns the timestamp of the last buffer played (in us).

                         int64_t getMediaTimeUs();

                    @@ -109,6 +111,10 @@ private:

                         AudioPlayer(const AudioPlayer &);

                         AudioPlayer &operator=(const AudioPlayer &);

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    int64_t mRealTimeInterpolation;

                    +    int64_t GetSystemTimeuSec();

                    +#endif

                     };

                     }  // namespace android

include/media/stagefright/CameraSource.h

show inline notes
View file @ 1a6862f

            
                    @@ -63,6 +63,9 @@ private:

                         List<sp<IMemory> > mFramesReceived;

                         List<sp<IMemory> > mFramesBeingEncoded;

                         List<int64_t> mFrameTimes;

                    +#if defined(OMAP_ENHANCEMENT) && (TARGET_OMAP4)

                    +    List<uint32_t> mFrameOffset;

                    +#endif

                         int64_t mStartTimeUs;

                         int64_t mFirstFrameTimeUs;

                    @@ -77,8 +80,14 @@ private:

                         CameraSource(const sp<Camera> &camera);

                    +#ifdef OMAP_ENHANCEMENT

                    +    void dataCallbackTimestamp(

                    +            int64_t timestampUs, int32_t msgType, const sp<IMemory> &data,

                    +            uint32_t offset=0, uint32_t stride=0);

                    +#else

                         void dataCallbackTimestamp(

                                 int64_t timestampUs, int32_t msgType, const sp<IMemory> &data);

                    +#endif

                         void releaseQueuedFrames();

                         void releaseOneRecordingFrame(const sp<IMemory>& frame);

include/media/stagefright/ColorConverter.h

show inline notes
View file @ 1a6862f

            
                    @@ -33,10 +33,18 @@ struct ColorConverter {

                         bool isValid() const;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    void convert(

                    +            size_t width, size_t height,

                    +            const void *srcBits, size_t srcSkip,

                    +            void *dstBits, size_t dstSkip,

                    +            size_t displaywidth=0, size_t displayheight=0,size_t offset=0,bool interlaced=false);

                    +#else

                         void convert(

                                 size_t width, size_t height,

                                 const void *srcBits, size_t srcSkip,

                                 void *dstBits, size_t dstSkip);

                    +#endif

                     private:

                         OMX_COLOR_FORMATTYPE mSrcFormat, mDstFormat;

                    @@ -83,6 +91,14 @@ private:

                             const uint8_t *blockUV, size_t blockWidth,

                             size_t blockHeight, size_t dstSkip);

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    void convertYUV420PackedSemiPlanar(

                    +            size_t width, size_t height,

                    +            size_t displaywidth, size_t displayheight, size_t offset,

                    +            const void *srcBits, size_t srcSkip,

                    +            void *dstBits, size_t dstSkip, bool interlaced);

                    +#endif

                    +

                         ColorConverter(const ColorConverter &);

                         ColorConverter &operator=(const ColorConverter &);

                     };

include/media/stagefright/HardwareAPI.h

show inline notes
View file @ 1a6862f

            
                    @@ -40,6 +40,24 @@ extern android::VideoRenderer *createRendererWithRotation(

                             size_t decodedWidth, size_t decodedHeight,

                             int32_t rotationDegrees);

                    +#ifdef OMAP_ENHANCEMENT

                    +extern android::VideoRenderer *createRenderer(

                    +        const android::sp<android::ISurface> &surface,

                    +        const char *componentName,

                    +        OMX_COLOR_FORMATTYPE colorFormat,

                    +        size_t displayWidth, size_t displayHeight,

                    +        size_t decodedWidth, size_t decodedHeight,

                    +        int isS3D, int numOfOpBuffers);

                    +

                    +extern android::VideoRenderer *createRendererWithRotation(

                    +        const android::sp<android::ISurface> &surface,

                    +        const char *componentName,

                    +        OMX_COLOR_FORMATTYPE colorFormat,

                    +        size_t displayWidth, size_t displayHeight,

                    +        size_t decodedWidth, size_t decodedHeight,

                    +        int32_t rotationDegrees,

                    +        int isS3D, int numOfOpBuffers);

                    +#endif

                     extern android::OMXPluginBase *createOMXPlugin();

                     #endif  // HARDWARE_API_H_

include/media/stagefright/MediaDefs.h

show inline notes
View file @ 1a6862f

            
                    @@ -27,6 +27,17 @@ extern const char *MEDIA_MIMETYPE_VIDEO_AVC;

                     extern const char *MEDIA_MIMETYPE_VIDEO_MPEG4;

                     extern const char *MEDIA_MIMETYPE_VIDEO_H263;

                     extern const char *MEDIA_MIMETYPE_VIDEO_RAW;

                    +#if defined(OMAP_ENHANCEMENT)

                    +#if defined(TARGET_OMAP4)

                    +extern const char *MEDIA_MIMETYPE_VIDEO_VP6;

                    +extern const char *MEDIA_MIMETYPE_VIDEO_VP7;

                    +#endif

                    +extern const char *MEDIA_MIMETYPE_CONTAINER_ASF;

                    +extern const char *MEDIA_MIMETYPE_VIDEO_WMV;

                    +extern const char *MEDIA_MIMETYPE_AUDIO_WMA;

                    +extern const char *MEDIA_MIMETYPE_AUDIO_WMAPRO;

                    +extern const char *MEDIA_MIMETYPE_AUDIO_WMALSL;

                    +#endif

                     extern const char *MEDIA_MIMETYPE_AUDIO_AMR_NB;

                     extern const char *MEDIA_MIMETYPE_AUDIO_AMR_WB;

                    @@ -41,9 +52,13 @@ extern const char *MEDIA_MIMETYPE_AUDIO_RAW;

                     extern const char *MEDIA_MIMETYPE_CONTAINER_MPEG4;

                     extern const char *MEDIA_MIMETYPE_CONTAINER_WAV;

                     extern const char *MEDIA_MIMETYPE_CONTAINER_OGG;

                    +

                     extern const char *MEDIA_MIMETYPE_CONTAINER_MATROSKA;

                     extern const char *MEDIA_MIMETYPE_CONTAINER_MPEG2TS;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +extern const char *MEDIA_MIMETYPE_CONTAINER_AVI;

                    +#endif

                     }  // namespace android

                     #endif  // MEDIA_DEFS_H_

include/media/stagefright/MediaErrors.h

show inline notes
View file @ 1a6862f

            
                    @@ -40,6 +40,9 @@ enum {

                         // Not technically an error.

                         INFO_FORMAT_CHANGED    = MEDIA_ERROR_BASE - 12,

                         INFO_DISCONTINUITY     = MEDIA_ERROR_BASE - 13,

                    +#ifdef OMAP_ENHANCEMENT

                    +    ERROR_OUT_OF_MEM       = MEDIA_ERROR_BASE - 14

                    +#endif

                     };

                     }  // namespace android

include/media/stagefright/MediaExtractor.h

show inline notes
View file @ 1a6862f

            
                    @@ -17,9 +17,10 @@

                     #ifndef MEDIA_EXTRACTOR_H_

                     #define MEDIA_EXTRACTOR_H_

                    -

                     #include <utils/RefBase.h>

                    +#include <utils/String8.h>

                    +

                     namespace android {

                     class DataSource;

                    @@ -33,10 +34,16 @@ public:

                         virtual size_t countTracks() = 0;

                         virtual sp<MediaSource> getTrack(size_t index) = 0;

                    -

                    +#ifdef OMAP_ENHANCEMENT

                         enum GetTrackMetaDataFlags {

                    -        kIncludeExtensiveMetaData = 1

                    +        kIncludeExtensiveMetaData = 1,

                    +        kSelectFirstSample = 2

                         };

                    +#else

                    +    enum GetTrackMetaDataFlags {

                    +        kIncludeExtensiveMetaData = 1

                    +     };

                    +#endif

                         virtual sp<MetaData> getTrackMetaData(

                                 size_t index, uint32_t flags = 0) = 0;

                    @@ -64,6 +71,9 @@ private:

                         MediaExtractor &operator=(const MediaExtractor &);

                     };

                    +bool SniffMPEG4(

                    +        const sp<DataSource> &source, String8 *mimeType, float *confidence);

                    +

                     }  // namespace android

                     #endif  // MEDIA_EXTRACTOR_H_

include/media/stagefright/MediaSource.h

show inline notes
View file @ 1a6862f

            
                    @@ -25,12 +25,20 @@

                     #ifdef USE_GETBUFFERINFO

                     #include <binder/IMemory.h>

                     #endif

                    +#ifdef OMAP_ENHANCEMENT

                    +#include <utils/Vector.h>

                    +#include "binder/IMemory.h"

                    +#endif

                     namespace android {

                     class MediaBuffer;

                     class MetaData;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +struct S3D_params;

                    +#endif

                    +

                     struct MediaSource : public RefBase {

                         MediaSource();

                    @@ -125,6 +133,18 @@ protected:

                     private:

                         MediaSource(const MediaSource &);

                         MediaSource &operator=(const MediaSource &);

                    +

                    +public:

                    +#ifdef OMAP_ENHANCEMENT

                    +    // Method to share externally allocated buffers with the Codec.

                    +    virtual void setBuffers(Vector< sp<IMemory> > mBufferAddresse, bool portReconfig = false) {}

                    +    // Method used to reset read position without consuming the buffer

                    +    virtual int64_t setSeekTo(const ReadOptions *options) { return 0; }

                    +    virtual int getNumofOutputBuffers() {return -1; }

                    +#if defined(TARGET_OMAP4)

                    +    virtual void parseSEIMessages(S3D_params &mS3Dparams) {}

                    +#endif

                    +#endif

                     };

                     }  // namespace android

include/media/stagefright/MetaData.h

show inline notes
View file @ 1a6862f

            
                    @@ -41,6 +41,10 @@ enum {

                         kKeyBitRate           = 'brte',  // int32_t (bps)

                         kKeyESDS              = 'esds',  // raw data

                         kKeyAVCC              = 'avcc',  // raw data

                    +#ifdef OMAP_ENHANCEMENT

                    +    kKeyStreamSpecificData= 'scsd',  // raw data

                    +    kKeyHdr               = 'hdrd',  // raw data

                    +#endif

                         kKeyVorbisInfo        = 'vinf',  // raw data

                         kKeyVorbisBooks       = 'vboo',  // raw data

                         kKeyWantsNALFragments = 'NALf',

                    @@ -79,6 +83,11 @@ enum {

                         // video profile and level

                         kKeyVideoProfile      = 'vprf',  // int32_t

                         kKeyVideoLevel        = 'vlev',  // int32_t

                    +#ifdef OMAP_ENHANCEMENT

                    +    kKeyNumRefFrames      = 'vnrf',  // int32_t

                    +    kKeyVideoFPS          = 'vfps',  // int32_t

                    +    kKeyVideoInterlaced   = 'vint',  // int32_t (bool)

                    +#endif

                         // Set this key to enable authoring files in 64-bit offset

                         kKey64BitFileOffset   = 'fobt',  // int32_t (bool)

                    @@ -102,6 +111,16 @@ enum {

                         kKeyValidSamples      = 'valD',  // int32_t

                         kKeyIsUnreadable      = 'unre',  // bool (int32_t)

                    +

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +    kKeyPaddedWidth       = 'pwid',   // int32_t

                    +    kKeyPaddedHeight      = 'phei',   // int32_t

                    +    kKeyOffset            = 'offs',   // int32_t

                    +    kKeyIsExtraData     = 'xdta',     // int32_t (bool)

                    +    kKeyS3dSupported     ='s3ds',    // int32_t (bool)

                    +    kKeySEIEncodingType  ='seit',    // int32_t

                    +    kKeyFrameLayout      ='frml',    // cstring

                    +#endif

                     };

                     enum {

include/media/stagefright/OMXCodec.h

show inline notes
View file @ 1a6862f

            
                    @@ -38,6 +38,13 @@ struct OMXCodec : public MediaSource,

                             // The client wants to access the output buffer's video

                             // data for example for thumbnail extraction.

                             kClientNeedsFramebuffer  = 4,

                    +#ifdef OMAP_ENHANCEMENT

                    +        kPreferThumbnailMode               = 0x8,

                    +        kPreferInterlacedOutputContent     = 0x10,

                    +        MAX_RESOLUTION = 414720, // video resolution for TI Vid Dec

                    +        MAX_RESOLUTION_WIDTH = 864, // video width for TI Vid Dec

                    +        MAX_RESOLUTION_HEIGHT = 864, // video height for TI Vid Dec

                    +#endif

                         };

                         static sp<MediaSource> Create(

                                 const sp<IOMX> &omx,

                    @@ -46,6 +53,16 @@ struct OMXCodec : public MediaSource,

                                 const char *matchComponentName = NULL,

                                 uint32_t flags = 0);

                    +#ifdef OMAP_ENHANCEMENT

                    +    static sp<MediaSource> Create(

                    +            const sp<IOMX> &omx,

                    +            const sp<MetaData> &meta, bool createEncoder,

                    +            const sp<MediaSource> &source,

                    +            IOMX::node_id &nodeId,

                    +            const char *matchComponentName = NULL,

                    +            uint32_t flags = 0);

                    +#endif

                    +

                         static void setComponentRole(

                                 const sp<IOMX> &omx, IOMX::node_id node, bool isEncoder,

                                 const char *mime);

                    @@ -54,7 +71,10 @@ struct OMXCodec : public MediaSource,

                         virtual status_t stop();

                         virtual sp<MetaData> getFormat();

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual void setBuffers(Vector< sp<IMemory> > mBufferAddresses, bool portReconfig = false);

                    +    virtual int getNumofOutputBuffers();

                    +#endif

                         virtual status_t read(

                                 MediaBuffer **buffer, const ReadOptions *options = NULL);

                    @@ -68,7 +88,9 @@ struct OMXCodec : public MediaSource,

                     protected:

                         virtual ~OMXCodec();

                    +#ifndef OMAP_ENHANCEMENT

                     private:

                    +#endif

                         // Make sure mLock is accessible to OMXCodecObserver

                         friend class OMXCodecObserver;

                    @@ -118,12 +140,21 @@ private:

                             kOutputBuffersAreUnreadable           = 8192,

                             kStoreMetaDataInInputVideoBuffers     = 16384,

                             kCanNotSetVideoParameters             = 32768,

                    -        kDoesNotRequireMemcpyOnOutputPort     = 65536

                    +        kDoesNotRequireMemcpyOnOutputPort     = 65536,

                    +#ifdef OMAP_ENHANCEMENT

                    +        kDecoderNeedsPortReconfiguration      = 131072,

                    +        kDecoderCantRenderSmallClips          = 262144,

                    +        kInterlacedOutputContent              = 524288,

                    +        kThumbnailMode                        = 1048576,

                    +#endif

                         };

                         struct BufferInfo {

                             IOMX::buffer_id mBuffer;

                             bool mOwnedByComponent;

                    +#ifdef OMAP_ENHANCEMENT

                    +        bool mOwnedByPlayer;

                    +#endif

                             sp<IMemory> mMem;

                             size_t mSize;

                             void *mData;

                    @@ -150,6 +181,11 @@ private:

                         sp<MemoryDealer> mDealer[2];

                         State mState;

                    +#ifdef OMAP_ENHANCEMENT

                    +    Vector< sp<IMemory> > mExtBufferAddresses;

                    +    uint32_t mStride;

                    +    nsecs_t mNSecsToWait;

                    +#endif

                         Vector<BufferInfo> mPortBuffers[2];

                         PortStatus mPortStatus[2];

                         bool mInitialBufferSubmit;

                    @@ -193,6 +229,11 @@ private:

                         void setVideoInputFormat(

                                 const char *mime, const sp<MetaData>& meta);

                    +#if defined (TARGET_OMAP4) && defined (OMAP_ENHANCEMENT)

                    +    status_t setupEncoderPresetParams(int32_t isS3DEnabled);

                    +    status_t setupEncoderFrameDataContentParams(const sp<MetaData>& meta);

                    +#endif

                    +

                         status_t setupBitRate(int32_t bitRate);

                         status_t setupErrorCorrectionParameters();

                         status_t setupH263EncoderParameters(const sp<MetaData>& meta);

                    @@ -263,11 +304,22 @@ private:

                         void dumpPortStatus(OMX_U32 portIndex);

                    +#ifdef OMAP_ENHANCEMENT

                    +public:

                    +#endif

                         status_t configureCodec(const sp<MetaData> &meta, uint32_t flags);

                    +#ifdef OMAP_ENHANCEMENT

                    +protected:

                    +    static uint32_t getComponentQuirks(const char *componentName, bool isEncoder, uint32_t flags = 0);

                    +    int32_t mVideoFPS;

                    +#if defined(TARGET_OMAP4)

                    +    void setS3DMetaDataConfig(int32_t frameContentType);

                    +#endif

                    +#else

                         static uint32_t getComponentQuirks(

                                 const char *componentName, bool isEncoder);

                    -

                    +#endif

                         static void findMatchingCodecs(

                                 const char *mime,

                                 bool createEncoder, const char *matchComponentName,

                    @@ -276,8 +328,59 @@ private:

                         OMXCodec(const OMXCodec &);

                         OMXCodec &operator=(const OMXCodec &);

                    +

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4) && defined (NPA_BUFFERS)

                    +    uint32_t mNumberOfNPABuffersSent;

                    +  uint32_t mThumbnailEOSSent;

                    +#endif

                     };

                    +#if defined(OMAP_ENHANCEMENT)

                    +struct OMXCodecObserver : public BnOMXObserver {

                    +    OMXCodecObserver() {

                    +    }

                    +

                    +    void setCodec(const sp<OMXCodec> &target) {

                    +        mTarget = target;

                    +    }

                    +

                    +    // from IOMXObserver

                    +    virtual void onMessage(const omx_message &msg) {

                    +         sp<OMXCodec> codec = mTarget.promote();

                    +

                    +        if (codec.get() != NULL) {

                    +            Mutex::Autolock autoLock(codec->mLock);

                    +            codec->on_message(msg);

                    +            codec.clear();

                    +        }

                    +    }

                    +

                    +protected:

                    +    virtual ~OMXCodecObserver() {}

                    +

                    +private:

                    +    wp<OMXCodec> mTarget;

                    +

                    +    OMXCodecObserver(const OMXCodecObserver &);

                    +    OMXCodecObserver &operator=(const OMXCodecObserver &);

                    +};

                    +

                    +template<class T>

                    +static void InitOMXParams(T *params) {

                    +    params->nSize = sizeof(T);

                    +    params->nVersion.s.nVersionMajor = 1;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    //Ducati strict OMX Version check

                    +    params->nVersion.s.nVersionMinor = 1;

                    +#else

                    +    params->nVersion.s.nVersionMinor = 0;

                    +#endif

                    +    params->nVersion.s.nRevision = 0;

                    +    params->nVersion.s.nStep = 0;

                    +}

                    +

                    +#endif

                    +

                     struct CodecProfileLevel {

                         OMX_U32 mProfile;

                         OMX_U32 mLevel;

include/media/stagefright/Utils.h

show inline notes
View file @ 1a6862f

            
                    @@ -19,11 +19,49 @@

                     #define UTILS_H_

                     #include <stdint.h>

                    +#ifdef OMAP_ENHANCEMENT

                    +#include <media/stagefright/openmax/OMX_Types.h>

                    +#include <media/stagefright/openmax/OMX_Index.h>

                    +#endif

                     namespace android {

                     #define FOURCC(c1, c2, c3, c4) \

                         (c1 << 24 | c2 << 16 | c3 << 8 | c4)

                    +#ifdef OMAP_ENHANCEMENT

                    +#ifndef MAKEFOURCC_WMC

                    +#define MAKEFOURCC_WMC(ch0, ch1, ch2, ch3) \

                    +        ((OMX_U32)(OMX_U8)(ch0) | ((OMX_U32)(OMX_U8)(ch1) << 8) |   \

                    +        ((OMX_U32)(OMX_U8)(ch2) << 16) | ((OMX_U32)(OMX_U8)(ch3) << 24 ))

                    +

                    +#define mmioFOURCC_WMC(ch0, ch1, ch2, ch3)  MAKEFOURCC_WMC(ch0, ch1, ch2, ch3)

                    +#endif

                    +

                    +#define FOURCC_WMV3     mmioFOURCC_WMC('W','M','V','3')

                    +#define FOURCC_WMV2     mmioFOURCC_WMC('W','M','V','2')

                    +#define FOURCC_WMV1     mmioFOURCC_WMC('W','M','V','1')

                    +#define FOURCC_WMVA     mmioFOURCC_WMC('W','M','V','A')

                    +#define FOURCC_WVC1     mmioFOURCC_WMC('W','V','C','1')

                    +

                    +#define VIDDEC_WMV_ELEMSTREAM                           0

                    +#define VIDDEC_WMV_RCVSTREAM                            1

                    +

                    +typedef enum VIDDEC_CUSTOM_PARAM_INDEX

                    +{

                    +    VideoDecodeCustomParamProcessMode = (OMX_IndexVendorStartUnused + 1),

                    +    VideoDecodeCustomParamH264BitStreamFormat,

                    +    VideoDecodeCustomParamWMVProfile,

                    +    VideoDecodeCustomParamWMVFileType,

                    +    VideoDecodeCustomParamParserEnabled,

                    +

                    +} VIDDEC_CUSTOM_PARAM_INDEX;

                    +

                    +typedef struct OMX_PARAM_WMVFILETYPE {

                    +    OMX_U32 nSize;

                    +    OMX_VERSIONTYPE nVersion;

                    +    OMX_U32 nWmvFileType;

                    +} OMX_PARAM_WMVFILETYPE;

                    +#endif

                     uint16_t U16_AT(const uint8_t *ptr);

                     uint32_t U32_AT(const uint8_t *ptr);

include/media/stagefright/VideoRenderer.h

show inline notes
View file @ 1a6862f

            
                    @@ -19,9 +19,24 @@

                     #define VIDEO_RENDERER_H_

                     #include <sys/types.h>

                    +#ifdef OMAP_ENHANCEMENT

                    +#include "binder/IMemory.h"

                    +#include <utils/Vector.h>

                    +#endif

                     namespace android {

                    +#ifdef OMAP_ENHANCEMENT

                    +typedef void (*release_rendered_buffer_callback)(const sp<IMemory>& mem, void *cookie);

                    +typedef struct {

                    +    uint32_t decoded_width;

                    +    uint32_t decoded_height;

                    +    uint32_t buffercount;

                    +    uint32_t display_width;

                    +    uint32_t display_height;

                    +    }render_resize_params;

                    +#endif

                    +

                     class VideoRenderer {

                     public:

                         virtual ~VideoRenderer() {}

                    @@ -29,6 +44,14 @@ public:

                         virtual void render(

                                 const void *data, size_t size, void *platformPrivate) = 0;

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual Vector< sp<IMemory> > getBuffers() = 0;

                    +    virtual bool setCallback(release_rendered_buffer_callback cb, void *cookie) {return false;}

                    +    virtual void set_s3d_frame_layout(uint32_t s3d_mode, uint32_t s3d_fmt, uint32_t s3d_order, uint32_t s3d_subsampling) {}

                    +    virtual void resizeRenderer(void* resize_params) = 0;

                    +    virtual void requestRendererClone(bool enable) = 0;

                    +#endif

                    +

                     protected:

                         VideoRenderer() {}

include/media/stagefright/openmax/OMX_Index.h

show inline notes
View file @ 1a6862f

            
                    @@ -58,7 +58,6 @@ extern "C" {

                      */

                     #include <OMX_Types.h>

                    -

                     /** The OMX_INDEXTYPE enumeration is used to select a structure when either

                      *  getting or setting parameters and/or configuration data.  Each entry in 

                      *  this enumeration maps to an OMX specified structure.  When the

include/surfaceflinger/ISurface.h

show inline notes
View file @ 1a6862f

            
                    @@ -48,6 +48,11 @@ protected:

                             CREATE_OVERLAY,

                             REQUEST_BUFFER,

                             SET_BUFFER_COUNT,

                    +#ifdef OMAP_ENHANCEMENT

                    +        CREATE_OVERLAY_S3D,

                    +        SET_DISPLAY_ID,

                    +        REQUEST_OVERLAY_CLONE

                    +#endif

                         };

                     public: 

                    @@ -109,6 +114,13 @@ public:

                         virtual sp<OverlayRef> createOverlay(

                                 uint32_t w, uint32_t h, int32_t format, int32_t orientation) = 0;

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual sp<OverlayRef> createOverlay(

                    +            uint32_t w, uint32_t h, int32_t format, int32_t orientation, int isS3D) = 0;

                    +    virtual void setDisplayId(int displayId) = 0;

                    +    virtual int  requestOverlayClone(bool enable) = 0;

                    +#endif

                    +

                     };

                     // ----------------------------------------------------------------------------

include/surfaceflinger/Surface.h

show inline notes
View file @ 1a6862f

            
                    @@ -79,6 +79,9 @@ public:

                         status_t    setAlpha(float alpha=1.0f);

                         status_t    setMatrix(float dsdx, float dtdx, float dsdy, float dtdy);

                         status_t    setFreezeTint(uint32_t tint);

                    +#ifdef OMAP_ENHANCEMENT

                    +    status_t    setDisplayId(int32_t displayId);

                    +#endif

                         static status_t writeSurfaceToParcel(

                                 const sp<SurfaceControl>& control, Parcel* parcel);

                    @@ -101,8 +104,9 @@ private:

                         // for testing

                         friend class Test;

                         const sp<ISurface>& getISurface() const { return mSurface; }

                    -    

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +    friend class OmapMMLibrary;

                    +#endif

                         friend class Surface;

                         SurfaceControl(

                    @@ -180,7 +184,9 @@ private:

                         friend class IOMX;

                         // this is just to be able to write some unit tests

                         friend class Test;

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +    friend class OmapMMLibrary;

                    +#endif

                     private:

                         friend class SurfaceComposerClient;

                         friend class SurfaceControl;

include/ui/FramebufferNativeWindow.h

show inline notes
View file @ 1a6862f

            
                    @@ -29,8 +29,15 @@

                     #include <ui/egl/android_natives.h>

                    +#ifdef OMAP_ENHANCEMENT

                    +/* Define number of buffers */

                    +#define NUM_FRAME_BUFFERS  2

                    +#endif

                     extern "C" EGLNativeWindowType android_createDisplaySurface(void);

                    +#ifdef OMAP_ENHANCEMENT

                    +extern "C" EGLNativeWindowType android_createDisplaySurfaceOnFB(uint32_t fb_idx);

                    +#endif

                     // ---------------------------------------------------------------------------

                     namespace android {

                    @@ -48,7 +55,11 @@ class FramebufferNativeWindow

                             LightRefBase<FramebufferNativeWindow> >

                     {

                     public:

                    -    FramebufferNativeWindow(); 

                    +#ifdef OMAP_ENHANCEMENT

                    +    FramebufferNativeWindow(uint32_t idx);

                    +#endif

                    +    FramebufferNativeWindow();

                    +

                         framebuffer_device_t const * getDevice() const { return fbDev; } 

                    @@ -72,7 +83,11 @@ private:

                         framebuffer_device_t* fbDev;

                         alloc_device_t* grDev;

                    +#ifdef OMAP_ENHANCEMENT

                    +    sp<NativeBuffer> buffers[NUM_FRAME_BUFFERS];

                    +#else

                         sp<NativeBuffer> buffers[2];

                    +#endif

                         sp<NativeBuffer> front;

                         mutable Mutex mutex;

                    @@ -83,7 +98,7 @@ private:

                         int32_t mCurrentBufferIndex;

                         bool mUpdateOnDemand;

                     };

                    -    

                    +

                     // ---------------------------------------------------------------------------

                     }; // namespace android

                     // ---------------------------------------------------------------------------

include/ui/Overlay.h

show inline notes
View file @ 1a6862f

            
                    @@ -88,6 +88,9 @@ public:

                         status_t setCrop(uint32_t x, uint32_t y, uint32_t w, uint32_t h) ;

                    +#ifdef OMAP_ENHANCEMENT

                    +    status_t set_s3d_params(int32_t s3d_mode, uint32_t s3d_fmt, uint32_t s3d_order, uint32_t s3d_subsampling);

                    +#endif

                         status_t getCrop(uint32_t* x, uint32_t* y, uint32_t* w, uint32_t* h) ;

                         /* set the buffer attributes */

libs/camera/Camera.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -388,7 +388,12 @@ void Camera::dataCallback(int32_t msgType, const sp<IMemory>& dataPtr)

                     }

                     // callback from camera service when timestamped frame is ready

                    +#ifdef OMAP_ENHANCEMENT

                    +void Camera::dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr,

                    +        uint32_t offset, uint32_t stride)

                    +#else

                     void Camera::dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr)

                    +#endif

                     {

                         sp<CameraListener> listener;

                         {

                    @@ -396,7 +401,11 @@ void Camera::dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<

                             listener = mListener;

                         }

                         if (listener != NULL) {

                    +#ifdef OMAP_ENHANCEMENT

                    +        listener->postDataTimestamp(timestamp, msgType, dataPtr, offset, stride);

                    +#else

                             listener->postDataTimestamp(timestamp, msgType, dataPtr);

                    +#endif

                         } else {

                             LOGW("No listener was set. Drop a recording frame.");

                             releaseRecordingFrame(dataPtr);

libs/camera/ICameraClient.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -62,13 +62,22 @@ public:

                         }

                         // generic data callback from camera service to app with image data

                    +#ifdef OMAP_ENHANCEMENT

                    +    void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& imageData,

                    +            uint32_t offset, uint32_t stride)

                    +#else

                         void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& imageData)

                    +#endif

                         {

                             LOGV("dataCallback");

                             Parcel data, reply;

                             data.writeInterfaceToken(ICameraClient::getInterfaceDescriptor());

                             data.writeInt64(timestamp);

                             data.writeInt32(msgType);

                    +#ifdef OMAP_ENHANCEMENT

                    +        data.writeInt32(offset);

                    +        data.writeInt32(stride);

                    +#endif

                             data.writeStrongBinder(imageData->asBinder());

                             remote()->transact(DATA_CALLBACK_TIMESTAMP, data, &reply, IBinder::FLAG_ONEWAY);

                         }

                    @@ -104,8 +113,16 @@ status_t BnCameraClient::onTransact(

                                 CHECK_INTERFACE(ICameraClient, data, reply);

                                 nsecs_t timestamp = data.readInt64();

                                 int32_t msgType = data.readInt32();

                    +#ifdef OMAP_ENHANCEMENT

                    +            int32_t offset = data.readInt32();

                    +            int32_t stride = data.readInt32();

                    +#endif

                                 sp<IMemory> imageData = interface_cast<IMemory>(data.readStrongBinder());

                    +#ifdef OMAP_ENHANCEMENT

                    +            dataCallbackTimestamp(timestamp, msgType, imageData, offset, stride);

                    +#else

                                 dataCallbackTimestamp(timestamp, msgType, imageData);

                    +#endif

                                 return NO_ERROR;

                             } break;

                             default:

libs/surfaceflinger_client/ISurface.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -144,6 +144,44 @@ public:

                             remote()->transact(CREATE_OVERLAY, data, &reply);

                             return OverlayRef::readFromParcel(reply);

                         }

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +   virtual sp<OverlayRef> createOverlay(

                    +             uint32_t w, uint32_t h, int32_t format, int32_t orientation, int isS3D)

                    +    {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(ISurface::getInterfaceDescriptor());

                    +        data.writeInt32(w);

                    +        data.writeInt32(h);

                    +        data.writeInt32(format);

                    +        data.writeInt32(orientation);

                    +      data.writeInt32(isS3D);

                    +        remote()->transact(CREATE_OVERLAY_S3D, data, &reply);

                    +        return OverlayRef::readFromParcel(reply);

                    +    }

                    +

                    +    virtual void setDisplayId(int displayId) {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(ISurface::getInterfaceDescriptor());

                    +        data.writeInt32(displayId);

                    +        remote()->transact(SET_DISPLAY_ID, data, &reply);

                    +        return;

                    +    }

                    +

                    +    virtual int requestOverlayClone(bool enable) {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(ISurface::getInterfaceDescriptor());

                    +        data.writeInt32((int)enable);

                    +        remote()->transact(REQUEST_OVERLAY_CLONE, data, &reply);

                    +        if (enable) {

                    +            return (dup(reply.readFileDescriptor()));

                    +        }

                    +        else {

                    +            return -1;

                    +        }

                    +    }

                    +#endif

                    +

                     };

                     IMPLEMENT_META_INTERFACE(Surface, "android.ui.ISurface");

                    @@ -208,6 +246,38 @@ status_t BnSurface::onTransact(

                                 sp<OverlayRef> o = createOverlay(w, h, f, orientation);

                                 return OverlayRef::writeToParcel(reply, o);

                             } break;

                    +#ifdef OMAP_ENHANCEMENT

                    +        case CREATE_OVERLAY_S3D: {

                    +            CHECK_INTERFACE(ISurface, data, reply);

                    +            int w = data.readInt32();

                    +            int h = data.readInt32();

                    +            int f = data.readInt32();

                    +            int orientation = data.readInt32();

                    +          bool isS3D = data.readInt32();

                    +            sp<OverlayRef> o = createOverlay(w, h, f, orientation, isS3D);

                    +            return OverlayRef::writeToParcel(reply, o);

                    +        } break;

                    +

                    +        case SET_DISPLAY_ID: {

                    +            CHECK_INTERFACE(ISurface, data, reply);

                    +            int dpy = data.readInt32();

                    +            setDisplayId(dpy);

                    +            return NO_ERROR;

                    +        } break;

                    +

                    +        case REQUEST_OVERLAY_CLONE: {

                    +            CHECK_INTERFACE(ISurface, data, reply);

                    +            int enable = data.readInt32();

                    +            int fd = requestOverlayClone(enable);

                    +            if (fd > 0) {

                    +                return reply->writeFileDescriptor(fd);

                    +            }

                    +            else {

                    +                return reply->writeInt32(fd);

                    +            }

                    +        }

                    +

                    +#endif

                             default:

                                 return BBinder::onTransact(code, data, reply, flags);

                         }

libs/ui/FramebufferNativeWindow.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -63,7 +63,6 @@ private:

                         ~NativeBuffer() { }; // this class cannot be overloaded

                     };

                    -

                     /*

                      * This implements the (main) framebuffer management. This class is used

                      * mostly by SurfaceFlinger, but also by command line GL application.

                    @@ -71,18 +70,22 @@ private:

                      * In fact this is an implementation of ANativeWindow on top of

                      * the framebuffer.

                      * 

                    - * Currently it is pretty simple, it manages only two buffers (the front and 

                    - * back buffer).

                    - * 

                    + * This implementation is able to manage any number of buffers,

                    + * defined by NUM_FRAME_BUFFERS (currently set to 2: front

                    + * and back buffer)

                    + *

                      */

                    -FramebufferNativeWindow::FramebufferNativeWindow() 

                    +FramebufferNativeWindow::FramebufferNativeWindow()

                         : BASE(), fbDev(0), grDev(0), mUpdateOnDemand(false)

                     {

                         hw_module_t const* module;

                         if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module) == 0) {

                             int stride;

                             int err;

                    +#ifdef OMAP_ENHANCEMENT

                    +        int i;

                    +#endif

                             err = framebuffer_open(module, &fbDev);

                             LOGE_IF(err, "couldn't open framebuffer HAL (%s)", strerror(-err));

                    @@ -96,9 +99,36 @@ FramebufferNativeWindow::FramebufferNativeWindow()

                             mUpdateOnDemand = (fbDev->setUpdateRect != 0);

                             // initialize the buffer FIFO

                    +#ifdef OMAP_ENHANCEMENT

                    +        mNumBuffers = NUM_FRAME_BUFFERS;

                    +        mNumFreeBuffers = NUM_FRAME_BUFFERS;

                    +#else

                             mNumBuffers = 2;

                             mNumFreeBuffers = 2;

                    +#endif

                             mBufferHead = mNumBuffers-1;

                    +#ifdef OMAP_ENHANCEMENT

                    +        for(i = 0; i < NUM_FRAME_BUFFERS; i++){

                    +            buffers[i] = new NativeBuffer(

                    +                    fbDev->width, fbDev->height, fbDev->format, GRALLOC_USAGE_HW_FB);

                    +        }

                    +

                    +        for(i = 0; i < NUM_FRAME_BUFFERS; i++){

                    +            err = grDev->alloc(grDev,

                    +                    fbDev->width, fbDev->height, fbDev->format,

                    +                    GRALLOC_USAGE_HW_FB, &buffers[i]->handle, &buffers[i]->stride);

                    +

                    +            LOGE_IF(err, "fb buffer %d allocation failed w=%d, h=%d, err=%s",

                    +                    i, fbDev->width, fbDev->height, strerror(-err));

                    +

                    +            if(err){

                    +                mNumBuffers = i;

                    +                mNumFreeBuffers = i;

                    +                mBufferHead = mNumBuffers-1;

                    +                break;

                    +            }

                    +       }

                    +#else

                             buffers[0] = new NativeBuffer(

                                     fbDev->width, fbDev->height, fbDev->format, GRALLOC_USAGE_HW_FB);

                             buffers[1] = new NativeBuffer(

                    @@ -117,7 +147,7 @@ FramebufferNativeWindow::FramebufferNativeWindow()

                             LOGE_IF(err, "fb buffer 1 allocation failed w=%d, h=%d, err=%s",

                                     fbDev->width, fbDev->height, strerror(-err));

                    -

                    +#endif

                             const_cast<uint32_t&>(ANativeWindow::flags) = fbDev->flags; 

                             const_cast<float&>(ANativeWindow::xdpi) = fbDev->xdpi;

                             const_cast<float&>(ANativeWindow::ydpi) = fbDev->ydpi;

                    @@ -136,10 +166,99 @@ FramebufferNativeWindow::FramebufferNativeWindow()

                         ANativeWindow::cancelBuffer = NULL;

                         ANativeWindow::query = query;

                         ANativeWindow::perform = perform;

                    +    ANativeWindow::cancelBuffer = 0;

                    +#ifdef OMAP_ENHANCEMENT

                    +    LOGE("%d buffers flip-chain implementation enabled\n", mNumBuffers);

                    +#endif

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +FramebufferNativeWindow::FramebufferNativeWindow(uint32_t idx)

                    +    : BASE(), fbDev(0), grDev(0), mUpdateOnDemand(false)

                    +{

                    +    hw_module_t const* module;

                    +

                    +    if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module) == 0) {

                    +        int stride;

                    +        int err;

                    +        int i;

                    +        const size_t SIZE = 16;

                    +        char fbname[SIZE];

                    +        snprintf(fbname, SIZE, "fb%u", idx);

                    +

                    +        err = framebuffer_open_by_name(module, &fbDev, fbname);

                    +        LOGE_IF(err, "couldn't open framebuffer HAL (%s)", strerror(-err));

                    +

                    +        err = gralloc_open(module, &grDev);

                    +        LOGE_IF(err, "couldn't open gralloc HAL (%s)", strerror(-err));

                    +

                    +        // bail out if we can't initialize the modules

                    +        if (!fbDev || !grDev)

                    +            return;

                    +

                    +        mUpdateOnDemand = (fbDev->setUpdateRect != 0);

                    +

                    +        // initialize the buffer FIFO

                    +        mNumBuffers = NUM_FRAME_BUFFERS;

                    +        mNumFreeBuffers = NUM_FRAME_BUFFERS;

                    +        mBufferHead = mNumBuffers-1;

                    +

                    +        for(i = 0; i < NUM_FRAME_BUFFERS; i++){

                    +            buffers[i] = new NativeBuffer(

                    +                    fbDev->width, fbDev->height, fbDev->format, GRALLOC_USAGE_HW_FB << idx);

                    +        }

                    +

                    +        for(i = 0; i < NUM_FRAME_BUFFERS; i++){

                    +            err = grDev->alloc(grDev,

                    +                    fbDev->width, fbDev->height, fbDev->format,

                    +                    GRALLOC_USAGE_HW_FB << idx, &buffers[i]->handle, &buffers[i]->stride);

                    +

                    +            LOGE_IF(err, "fb buffer %d allocation failed w=%d, h=%d, err=%s",

                    +                    i, fbDev->width, fbDev->height, strerror(-err));

                    +

                    +            if(err){

                    +                mNumBuffers = i;

                    +                mNumFreeBuffers = i;

                    +                mBufferHead = mNumBuffers-1;

                    +                break;

                    +            }

                    +       }

                    +

                    +        const_cast<uint32_t&>(ANativeWindow::flags) = fbDev->flags;

                    +        const_cast<float&>(ANativeWindow::xdpi) = fbDev->xdpi;

                    +        const_cast<float&>(ANativeWindow::ydpi) = fbDev->ydpi;

                    +        const_cast<int&>(ANativeWindow::minSwapInterval) =

                    +            fbDev->minSwapInterval;

                    +        const_cast<int&>(ANativeWindow::maxSwapInterval) =

                    +            fbDev->maxSwapInterval;

                    +    } else {

                    +        LOGE("Couldn't get gralloc module");

                    +    }

                    +

                    +    ANativeWindow::setSwapInterval = setSwapInterval;

                    +    ANativeWindow::dequeueBuffer = dequeueBuffer;

                    +    ANativeWindow::lockBuffer = lockBuffer;

                    +    ANativeWindow::queueBuffer = queueBuffer;

                    +    ANativeWindow::query = query;

                    +    ANativeWindow::perform = perform;

                    +

                    +    LOGE("%d buffers flip-chain implementation enabled\n", mNumBuffers);

                    +}

                    +#endif

                    +

                     FramebufferNativeWindow::~FramebufferNativeWindow() 

                     {

                    +#ifdef OMAP_ENHANCEMENT

                    +    int i;

                    +

                    +   if (grDev){

                    +        for (i = 0; i < mNumBuffers; i++){

                    +            if (buffers[i] != NULL)

                    +                grDev->free(grDev, buffers[i]->handle);

                    +        }

                    +        gralloc_close(grDev);

                    +    }

                    +#else

                         if (grDev) {

                             if (buffers[0] != NULL)

                                 grDev->free(grDev, buffers[0]->handle);

                    @@ -147,7 +266,7 @@ FramebufferNativeWindow::~FramebufferNativeWindow()

                                 grDev->free(grDev, buffers[1]->handle);

                             gralloc_close(grDev);

                         }

                    -

                    +#endif

                         if (fbDev) {

                             framebuffer_close(fbDev);

                         }

                    @@ -295,6 +414,20 @@ int FramebufferNativeWindow::perform(ANativeWindow* window,

                     using namespace android;

                    +#ifdef OMAP_ENHANCEMENT

                    +EGLNativeWindowType android_createDisplaySurfaceOnFB(uint32_t fb_idx)

                    +{

                    +    FramebufferNativeWindow* w;

                    +    w = new FramebufferNativeWindow(fb_idx);

                    +    if (w->getDevice() == NULL) {

                    +        // get a ref so it can be destroyed when we exit this block

                    +        sp<FramebufferNativeWindow> ref(w);

                    +        return NULL;

                    +    }

                    +    return (EGLNativeWindowType)w;

                    +}

                    +#endif

                    +

                     EGLNativeWindowType android_createDisplaySurface(void)

                     {

                         FramebufferNativeWindow* w;

libs/ui/Overlay.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -78,6 +78,14 @@ status_t Overlay::setCrop(uint32_t x, uint32_t y, uint32_t w, uint32_t h)

                         return mOverlayData->setCrop(mOverlayData, x, y, w, h);

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +status_t Overlay::set_s3d_params(int32_t s3d_mode, uint32_t s3d_fmt, uint32_t s3d_order, uint32_t s3d_subsampling)

                    +{

                    +    if (mStatus != NO_ERROR) return mStatus;

                    +    return mOverlayData->set_s3d_params(mOverlayData, s3d_mode, s3d_fmt, s3d_order, s3d_subsampling);

                    +}

                    +#endif

                    +

                     status_t Overlay::getCrop(uint32_t* x, uint32_t* y, uint32_t* w, uint32_t* h)

                     {

                         if (mStatus != NO_ERROR) return mStatus;

media/java/android/media/AudioService.java

show inline notes
View file @ 1a6862f

            
                    @@ -120,6 +120,15 @@ public class AudioService extends IAudioService.Stub {

                         private int mMode;

                         private Object mSettingsLock = new Object();

                         private boolean mMediaServerOk;

                    +    /*

                    +     * OMAP4 specific intents that the AudioService

                    +     * will register to recieve

                    +     */

                    +    private static final String ACTION_FM_PLUG = "android.intent.action.FM_PLUG";

                    +    private static final String ACTION_FMTX_PLUG = "android.intent.action.FMTX_PLUG";

                    +    private static final String POWER_MODE = "omap.audio.power";

                    +    private static final String MAIN_MIC_CHOICE = "omap.audio.mic.main";

                    +    private static final String SUB_MIC_CHOICE = "omap.audio.mic.sub";

                         private SoundPool mSoundPool;

                         private Object mSoundEffectsLock = new Object();

                    @@ -305,6 +314,14 @@ public class AudioService extends IAudioService.Stub {

                             // Register for device connection intent broadcasts.

                             IntentFilter intentFilter =

                                     new IntentFilter(Intent.ACTION_HEADSET_PLUG);

                    +        if (SystemProperties.OMAP_ENHANCEMENT) {

                    +            intentFilter.addAction(ACTION_FM_PLUG);

                    +            intentFilter.addAction(ACTION_FMTX_PLUG);

                    +            intentFilter.addAction(POWER_MODE);

                    +            intentFilter.addAction(MAIN_MIC_CHOICE);

                    +            intentFilter.addAction(SUB_MIC_CHOICE);

                    +        }

                    +

                             intentFilter.addAction(BluetoothA2dp.ACTION_SINK_STATE_CHANGED);

                             intentFilter.addAction(BluetoothHeadset.ACTION_STATE_CHANGED);

                             intentFilter.addAction(Intent.ACTION_DOCK_EVENT);

                    @@ -1981,6 +1998,80 @@ public class AudioService extends IAudioService.Stub {

                                             }

                                         }

                                     }

                    +           } else if (SystemProperties.OMAP_ENHANCEMENT && action.equals(ACTION_FM_PLUG)) {

                    +               int state = intent.getIntExtra("state",0);

                    +

                    +               boolean isConnected = mConnectedDevices.containsKey(AudioSystem.DEVICE_IN_FM_ANALOG );

                    +               if (state == 0 && isConnected) {

                    +                      Log.v(TAG,"calling FM Rx Analog  Off");

                    +                      AudioSystem.setDeviceConnectionState(AudioSystem.DEVICE_IN_FM_ANALOG ,

                    +                               AudioSystem.DEVICE_STATE_UNAVAILABLE,"");

                    +                      mConnectedDevices.remove(AudioSystem.DEVICE_IN_FM_ANALOG );

                    +               } else if (state == 1 && !isConnected)  {

                    +                      Log.v(TAG,"calling FM Rx Analog On");

                    +                      AudioSystem.setDeviceConnectionState(AudioSystem.DEVICE_IN_FM_ANALOG ,

                    +                                AudioSystem.DEVICE_STATE_AVAILABLE,"");

                    +                      mConnectedDevices.put( new Integer(AudioSystem.DEVICE_IN_FM_ANALOG ), "");

                    +               }

                    +           } else if (SystemProperties.OMAP_ENHANCEMENT && action.equals(ACTION_FMTX_PLUG)) {

                    +               int state = intent.getIntExtra("state",0);

                    +

                    +               boolean isConnected = mConnectedDevices.containsKey(AudioSystem.DEVICE_OUT_FM_TRANSMIT );

                    +               if (state == 0 && isConnected) {

                    +                      Log.e(TAG,"calling FM Transmit Off");

                    +                      AudioSystem.setDeviceConnectionState(AudioSystem.DEVICE_OUT_FM_TRANSMIT ,

                    +                               AudioSystem.DEVICE_STATE_UNAVAILABLE,"");

                    +                      mConnectedDevices.remove(AudioSystem.DEVICE_OUT_FM_TRANSMIT );

                    +               } else if (state == 1 && !isConnected)  {

                    +                      Log.e(TAG,"calling FM Transmit On");

                    +                      AudioSystem.setDeviceConnectionState(AudioSystem.DEVICE_OUT_FM_TRANSMIT ,

                    +                                AudioSystem.DEVICE_STATE_AVAILABLE,"");

                    +                      mConnectedDevices.put( new Integer(AudioSystem.DEVICE_OUT_FM_TRANSMIT ), "");

                    +               }

                    +            } else if (SystemProperties.OMAP_ENHANCEMENT && action.equals(POWER_MODE)) {

                    +                Intent noisyIntent = new Intent(AudioManager.ACTION_AUDIO_BECOMING_NOISY);

                    +                mContext.sendBroadcast(noisyIntent);

                    +                boolean isConnected = mConnectedDevices.containsKey(AudioSystem.DEVICE_OUT_WIRED_HEADSET) |

                    +                                      mConnectedDevices.containsKey(AudioSystem.DEVICE_OUT_WIRED_HEADPHONE);

                    +                if (intent.getBooleanExtra("LP", false) && isConnected) {

                    +                    // enable low power mode

                    +                    AudioSystem.setDeviceConnectionState(AudioSystem.DEVICE_OUT_LOW_POWER ,

                    +                                                         AudioSystem.DEVICE_STATE_AVAILABLE,"");

                    +                    mConnectedDevices.put(new Integer(AudioSystem.DEVICE_OUT_LOW_POWER), "");

                    +                    Log.e(TAG,"Action: power mode is now LP, re-routing");

                    +                }

                    +                else {

                    +                    Log.e(TAG,"Action: power mode is now HQ, re-routing");

                    +                    AudioSystem.setDeviceConnectionState(AudioSystem.DEVICE_OUT_LOW_POWER ,

                    +                                                         AudioSystem.DEVICE_STATE_UNAVAILABLE,"");

                    +                    mConnectedDevices.remove(AudioSystem.DEVICE_OUT_LOW_POWER);

                    +                }

                    +            } else if (SystemProperties.OMAP_ENHANCEMENT && action.equals(MAIN_MIC_CHOICE)) {

                    +                /*

                    +                 * mic choice is not configurable by intent yet, this is here for future use.

                    +                 * eventually, the mic choice will be set from applications using this intent

                    +                 * and we will update the logic to be flexible for mics other than DMIC0.

                    +                 */

                    +                Intent noisyIntent = new Intent(AudioManager.ACTION_AUDIO_BECOMING_NOISY);

                    +                mContext.sendBroadcast(noisyIntent);

                    +                if (intent.getBooleanExtra("DMic0L", true)) {

                    +                     Log.e(TAG,"MAIN MIC - DMIC0L selected");

                    +                } else if (intent.getBooleanExtra("AMic0", true)) {

                    +                    Log.e(TAG,"MAIN MIC - AMIC selected");

                    +                } else {

                    +                    Log.e(TAG,"MAIN MIC - invalid selection, only [DMIC0L,AMIC0] supported");

                    +                }

                    +            } else if (SystemProperties.OMAP_ENHANCEMENT && action.equals(SUB_MIC_CHOICE)) {

                    +                // mic choice is not configurable by intent yet, this is here for future use

                    +                Intent noisyIntent = new Intent(AudioManager.ACTION_AUDIO_BECOMING_NOISY);

                    +                mContext.sendBroadcast(noisyIntent);

                    +                if (intent.getBooleanExtra("DMic0R", true)) {

                    +                    Log.e(TAG,"SUB MIC - DMIC0R selected");

                    +                } else if (intent.getBooleanExtra("AMic1", true)) {

                    +                    Log.e(TAG,"SUB MIC - AMIC selected");

                    +                } else {

                    +                    Log.e(TAG,"SUB MIC - invalid selection, only [DMIC0R,AMIC] supported");

                    +                }

                                 }

                             }

                         }

media/java/android/media/AudioSystem.java

show inline notes
View file @ 1a6862f

            
                    @@ -260,6 +260,10 @@ public class AudioSystem

                         public static final int DEVICe_IN_FM_RX = 0x1000000;

                         public static final int DEVICe_IN_FM_RXA2DP = 0x2000000;

                         public static final int DEVICE_IN_DEFAULT = 0x80000000;

                    +    // For OMAP

                    +    public static final int DEVICE_OUT_FM_TRANSMIT = 0x800;

                    +    public static final int DEVICE_IN_FM_ANALOG = 0x1000000;

                    +    public static final int DEVICE_OUT_LOW_POWER = 0x1000;

                         // device states

                         public static final int DEVICE_STATE_UNAVAILABLE = 0;

media/java/android/media/DecoderCapabilities.java

show inline notes
View file @ 1a6862f

            
                    @@ -33,6 +33,8 @@ public class DecoderCapabilities

                          */

                         public enum VideoDecoder {

                             VIDEO_DECODER_WMV,

                    +        VIDEO_DECODER_VP6,

                    +        VIDEO_DECODER_VP7,

                         };

                         /**

media/java/android/media/MediaFile.java

show inline notes
View file @ 1a6862f

            
                    @@ -23,6 +23,7 @@ import android.provider.MediaStore.Video;

                     import android.media.DecoderCapabilities;

                     import android.media.DecoderCapabilities.VideoDecoder;

                     import android.media.DecoderCapabilities.AudioDecoder;

                    +import android.os.SystemProperties;

                     import java.util.HashMap;

                     import java.util.Iterator;

                    @@ -57,7 +58,7 @@ public class MediaFile {

                         public static final int FILE_TYPE_IMY     = 13;

                         private static final int FIRST_MIDI_FILE_TYPE = FILE_TYPE_MID;

                         private static final int LAST_MIDI_FILE_TYPE = FILE_TYPE_IMY;

                    -   

                    +

                         // Video file types

                         public static final int FILE_TYPE_MP4     = 21;

                         public static final int FILE_TYPE_M4V     = 22;

                    @@ -65,42 +66,49 @@ public class MediaFile {

                         public static final int FILE_TYPE_3GPP2   = 24;

                         public static final int FILE_TYPE_WMV     = 25;

                         public static final int FILE_TYPE_ASF     = 26;

                    +

                         public static final int FILE_TYPE_MKV     = 27;

                         public static final int FILE_TYPE_MP2TS   = 28;

                         private static final int FIRST_VIDEO_FILE_TYPE = FILE_TYPE_MP4;

                    -    private static final int LAST_VIDEO_FILE_TYPE = FILE_TYPE_MP2TS;

                    -    

                    +

                    +    public static final int FILE_TYPE_AVI     = 29;

                    +    private static final int LAST_VIDEO_FILE_TYPE = FILE_TYPE_AVI;

                    +

                         // Image file types

                         public static final int FILE_TYPE_JPEG    = 31;

                         public static final int FILE_TYPE_GIF     = 32;

                         public static final int FILE_TYPE_PNG     = 33;

                         public static final int FILE_TYPE_BMP     = 34;

                         public static final int FILE_TYPE_WBMP    = 35;

                    +    public static final int FILE_TYPE_JPS    = 36;

                    +    public static final int FILE_TYPE_MPO    = 37;

                    +

                         private static final int FIRST_IMAGE_FILE_TYPE = FILE_TYPE_JPEG;

                         private static final int LAST_IMAGE_FILE_TYPE = FILE_TYPE_WBMP;

                    -   

                    +    private static final int LAST_IMAGE_FILE_TYPE_S3D = FILE_TYPE_MPO;

                    +

                         // Playlist file types

                         public static final int FILE_TYPE_M3U     = 41;

                         public static final int FILE_TYPE_PLS     = 42;

                         public static final int FILE_TYPE_WPL     = 43;

                         private static final int FIRST_PLAYLIST_FILE_TYPE = FILE_TYPE_M3U;

                         private static final int LAST_PLAYLIST_FILE_TYPE = FILE_TYPE_WPL;

                    -    

                    +

                         static class MediaFileType {

                    -    

                    +

                             int fileType;

                             String mimeType;

                    -        

                    +

                             MediaFileType(int fileType, String mimeType) {

                                 this.fileType = fileType;

                                 this.mimeType = mimeType;

                             }

                         }

                    -    

                    -    private static HashMap<String, MediaFileType> sFileTypeMap 

                    +

                    +    private static HashMap<String, MediaFileType> sFileTypeMap

                                 = new HashMap<String, MediaFileType>();

                    -    private static HashMap<String, Integer> sMimeTypeMap 

                    -            = new HashMap<String, Integer>();            

                    +    private static HashMap<String, Integer> sMimeTypeMap

                    +            = new HashMap<String, Integer>();

                         static void addFileType(String extension, int fileType, String mimeType) {

                             sFileTypeMap.put(extension, new MediaFileType(fileType, mimeType));

                             sMimeTypeMap.put(mimeType, Integer.valueOf(fileType));

                    @@ -149,7 +157,7 @@ public class MediaFile {

                             addFileType("IMY", FILE_TYPE_IMY, "audio/imelody");

                             addFileType("RTX", FILE_TYPE_MID, "audio/midi");

                             addFileType("OTA", FILE_TYPE_MID, "audio/midi");

                    -        

                    +

                             addFileType("MPEG", FILE_TYPE_MP4, "video/mpeg");

                             addFileType("MP4", FILE_TYPE_MP4, "video/mp4");

                             addFileType("M4V", FILE_TYPE_M4V, "video/mp4");

                    @@ -165,14 +173,22 @@ public class MediaFile {

                                 addFileType("WMV", FILE_TYPE_WMV, "video/x-ms-wmv");

                                 addFileType("ASF", FILE_TYPE_ASF, "video/x-ms-asf");

                             }

                    -

                    +        if("true".equals(System.getProperty("omap.enhancement"))) {

                    +            addFileType("AVI", FILE_TYPE_AVI, "video/avi");

                    +        }

                             addFileType("JPG", FILE_TYPE_JPEG, "image/jpeg");

                             addFileType("JPEG", FILE_TYPE_JPEG, "image/jpeg");

                             addFileType("GIF", FILE_TYPE_GIF, "image/gif");

                             addFileType("PNG", FILE_TYPE_PNG, "image/png");

                             addFileType("BMP", FILE_TYPE_BMP, "image/x-ms-bmp");

                             addFileType("WBMP", FILE_TYPE_WBMP, "image/vnd.wap.wbmp");

                    - 

                    +

                    +        if(SystemProperties.OMAP_ENHANCEMENT)

                    +        {

                    +        addFileType("JPS", FILE_TYPE_JPS, "image/jps");

                    +        addFileType("MPO", FILE_TYPE_MPO, "image/mpo");

                    +       }

                    +

                             addFileType("M3U", FILE_TYPE_M3U, "audio/x-mpegurl");

                             addFileType("PLS", FILE_TYPE_PLS, "audio/x-scpls");

                             addFileType("WPL", FILE_TYPE_WPL, "application/vnd.ms-wpl");

                    @@ -180,45 +196,52 @@ public class MediaFile {

                             // compute file extensions list for native Media Scanner

                             StringBuilder builder = new StringBuilder();

                             Iterator<String> iterator = sFileTypeMap.keySet().iterator();

                    -        

                    +

                             while (iterator.hasNext()) {

                                 if (builder.length() > 0) {

                                     builder.append(',');

                                 }

                                 builder.append(iterator.next());

                    -        } 

                    +        }

                             sFileExtensions = builder.toString();

                         }

                    -    

                    +

                         public static boolean isAudioFileType(int fileType) {

                             return ((fileType >= FIRST_AUDIO_FILE_TYPE &&

                                     fileType <= LAST_AUDIO_FILE_TYPE) ||

                                     (fileType >= FIRST_MIDI_FILE_TYPE &&

                                     fileType <= LAST_MIDI_FILE_TYPE));

                         }

                    -    

                    +

                         public static boolean isVideoFileType(int fileType) {

                             return (fileType >= FIRST_VIDEO_FILE_TYPE &&

                                     fileType <= LAST_VIDEO_FILE_TYPE);

                         }

                    -    

                    +

                         public static boolean isImageFileType(int fileType) {

                    +    if(SystemProperties.OMAP_ENHANCEMENT)

                    +        {

                    +            return (fileType >= FIRST_IMAGE_FILE_TYPE &&

                    +                    fileType <= LAST_IMAGE_FILE_TYPE_S3D);

                    +        }

                    +    else

                    +        {

                             return (fileType >= FIRST_IMAGE_FILE_TYPE &&

                                     fileType <= LAST_IMAGE_FILE_TYPE);

                    +        }

                         }

                    -    

                    +

                         public static boolean isPlayListFileType(int fileType) {

                             return (fileType >= FIRST_PLAYLIST_FILE_TYPE &&

                                     fileType <= LAST_PLAYLIST_FILE_TYPE);

                         }

                    -    

                    +

                         public static MediaFileType getFileType(String path) {

                             int lastDot = path.lastIndexOf(".");

                             if (lastDot < 0)

                                 return null;

                             return sFileTypeMap.get(path.substring(lastDot + 1).toUpperCase());

                         }

                    -    

                         public static int getFileTypeForMimeType(String mimeType) {

                             Integer value = sMimeTypeMap.get(mimeType);

                             return (value == null ? 0 : value.intValue());

media/java/android/media/MediaRecorder.java

show inline notes
View file @ 1a6862f

            
                    @@ -28,6 +28,7 @@ import java.io.FileNotFoundException;

                     import java.io.FileOutputStream;

                     import java.io.FileDescriptor;

                     import java.lang.ref.WeakReference;

                    +import android.os.SystemProperties;

                     /**

                      * Used to record audio and video. The recording control is based on a

                    @@ -302,11 +303,24 @@ public class MediaRecorder

                             setVideoFrameRate(profile.videoFrameRate);

                             setVideoSize(profile.videoFrameWidth, profile.videoFrameHeight);

                             setVideoEncodingBitRate(profile.videoBitRate);

                    -        setAudioEncodingBitRate(profile.audioBitRate);

                    -        setAudioChannels(profile.audioChannels);

                    -        setAudioSamplingRate(profile.audioSampleRate);

                    -        setVideoEncoder(profile.videoCodec);

                    -        setAudioEncoder(profile.audioCodec);

                    +

                    +        if(SystemProperties.OMAP_ENHANCEMENT) {

                    +            setVideoEncoder(profile.videoCodec);

                    +

                    +            if (profile.audioCodec != 0)

                    +            {

                    +                setAudioEncodingBitRate(profile.audioBitRate);

                    +                setAudioChannels(profile.audioChannels);

                    +                setAudioSamplingRate(profile.audioSampleRate);

                    +                setAudioEncoder(profile.audioCodec);

                    +            }

                    +        } else {

                    +            setAudioEncodingBitRate(profile.audioBitRate);

                    +            setAudioChannels(profile.audioChannels);

                    +            setAudioSamplingRate(profile.audioSampleRate);

                    +            setVideoEncoder(profile.videoCodec);

                    +            setAudioEncoder(profile.audioCodec);

                    +        }

                         }

                         /**

media/java/android/media/MediaScanner.java

show inline notes
View file @ 1a6862f

            
                    @@ -45,6 +45,7 @@ import android.text.TextUtils;

                     import android.util.Config;

                     import android.util.Log;

                     import android.util.Xml;

                    +import android.os.SystemProperties;

                     import java.io.BufferedReader;

                     import java.io.File;

                    @@ -735,7 +736,9 @@ public class MediaScanner

                                     values.put(Audio.Media.IS_ALARM, alarms);

                                     values.put(Audio.Media.IS_MUSIC, music);

                                     values.put(Audio.Media.IS_PODCAST, podcasts);

                    -            } else if (mFileType == MediaFile.FILE_TYPE_JPEG) {

                    +            } else if ((mFileType == MediaFile.FILE_TYPE_JPEG) ||

                    +                       ((SystemProperties.OMAP_ENHANCEMENT) && (mFileType == MediaFile.FILE_TYPE_JPS)) ||

                    +                       ((SystemProperties.OMAP_ENHANCEMENT) && (mFileType == MediaFile.FILE_TYPE_MPO))) {

                                     ExifInterface exif = null;

                                     try {

                                         exif = new ExifInterface(entry.mPath);

media/java/android/media/ThumbnailUtils.java

show inline notes
View file @ 1a6862f

            
                    @@ -33,6 +33,7 @@ import android.provider.BaseColumns;

                     import android.provider.MediaStore.Images;

                     import android.provider.MediaStore.Images.Thumbnails;

                     import android.util.Log;

                    +import android.os.SystemProperties;

                     import java.io.FileInputStream;

                     import java.io.FileDescriptor;

                    @@ -98,7 +99,9 @@ public class ThumbnailUtils {

                             SizedThumbnailBitmap sizedThumbnailBitmap = new SizedThumbnailBitmap();

                             Bitmap bitmap = null;

                             MediaFileType fileType = MediaFile.getFileType(filePath);

                    -        if (fileType != null && fileType.fileType == MediaFile.FILE_TYPE_JPEG) {

                    +        if (fileType != null && ((fileType.fileType == MediaFile.FILE_TYPE_JPEG) ||

                    +                                 ((SystemProperties.OMAP_ENHANCEMENT) && (fileType.fileType == MediaFile.FILE_TYPE_JPS)) ||

                    +                                 ((SystemProperties.OMAP_ENHANCEMENT)&& (fileType.fileType == MediaFile.FILE_TYPE_MPO)))){

                                 createThumbnailFromEXIF(filePath, targetSize, maxPixels, sizedThumbnailBitmap);

                                 bitmap = sizedThumbnailBitmap.mBitmap;

                             }

media/libmedia/Android.mk

show inline notes
View file @ 1a6862f

            
                    @@ -58,4 +58,12 @@ LOCAL_C_INCLUDES := \

                         external/icu4c/common \

                         external/expat/lib

                    +ifeq ($(OMAP_ENHANCEMENT),true)

                    +

                    +LOCAL_SRC_FILES += OverlayRenderer.cpp

                    +

                    +LOCAL_C_INCLUDES += $(TOP)/hardware/ti/omap3/liboverlay

                    +

                    +endif

                    +

                     include $(BUILD_SHARED_LIBRARY)

media/libmedia/IAudioFlinger.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -71,7 +71,11 @@ enum {

                         GET_EFFECT_DESCRIPTOR,

                         CREATE_EFFECT,

                         MOVE_EFFECTS,

                    +#ifdef OMAP_ENHANCEMENT

                    +    SET_FMRX_ACTIVE

                    +#else

                         SET_FM_VOLUME

                    +#endif

                     };

                     class BpAudioFlinger : public BpInterface<IAudioFlinger>

                    @@ -271,7 +275,16 @@ public:

                             remote()->transact(SET_STREAM_MUTE, data, &reply);

                             return reply.readInt32();

                         }

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual status_t setFMRxActive( bool state)

                    +    {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(IAudioFlinger::getInterfaceDescriptor());

                    +        data.writeInt32(state);

                    +        remote()->transact(SET_FMRX_ACTIVE, data, &reply);

                    +        return reply.readInt32();

                    +    }

                    +#endif

                         virtual float streamVolume(int stream, int output) const

                         {

                             Parcel data, reply;

                    @@ -808,6 +821,13 @@ status_t BnAudioFlinger::onTransact(

                                 reply->writeInt32( setStreamMute(stream, data.readInt32()) );

                                 return NO_ERROR;

                             } break;

                    +#ifdef OMAP_ENHANCEMENT

                    +        case SET_FMRX_ACTIVE: {

                    +            CHECK_INTERFACE(IAudioFlinger, data, reply);

                    +            reply->writeInt32( setFMRxActive(data.readInt32()) );

                    +            return NO_ERROR;

                    +        } break;

                    +#endif

                             case STREAM_VOLUME: {

                                 CHECK_INTERFACE(IAudioFlinger, data, reply);

                                 int stream = data.readInt32();

media/libmedia/IMediaPlayer.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -46,7 +46,10 @@ enum {

                         SUSPEND,

                         RESUME,

                         SET_AUX_EFFECT_SEND_LEVEL,

                    -    ATTACH_AUX_EFFECT

                    +    ATTACH_AUX_EFFECT,

                    +#ifdef OMAP_ENHANCEMENT

                    +    REQUEST_CLONE_MODE

                    +#endif

                     };

                     class BpMediaPlayer: public BpInterface<IMediaPlayer>

                    @@ -241,6 +244,17 @@ public:

                             remote()->transact(ATTACH_AUX_EFFECT, data, &reply);

                             return reply.readInt32();

                         }

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +    status_t requestVideoCloneMode(bool enable) {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(IMediaPlayer::getInterfaceDescriptor());

                    +        data.writeInt32((int)enable);

                    +        remote()->transact(REQUEST_CLONE_MODE, data, &reply);

                    +        return reply.readInt32();

                    +    }

                    +

                    +#endif

                     };

                     IMPLEMENT_META_INTERFACE(MediaPlayer, "android.media.IMediaPlayer");

                    @@ -369,6 +383,13 @@ status_t BnMediaPlayer::onTransact(

                                 reply->writeInt32(attachAuxEffect(data.readInt32()));

                                 return NO_ERROR;

                             } break;

                    +#ifdef OMAP_ENHANCEMENT

                    +        case REQUEST_CLONE_MODE: {

                    +            CHECK_INTERFACE(IMediaPlayer, data, reply);

                    +            reply->writeInt32(requestVideoCloneMode(data.readInt32()));

                    +            return NO_ERROR;

                    +        } break;

                    +#endif

                             default:

                                 return BBinder::onTransact(code, data, reply, flags);

                         }

media/libmedia/IMediaPlayerService.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -23,9 +23,12 @@

                     #include <media/IMediaPlayerService.h>

                     #include <media/IMediaRecorder.h>

                     #include <media/IOMX.h>

                    -

                     #include <utils/Errors.h>  // for status_t

                    +#ifdef OMAP_ENHANCEMENT

                    +#include <media/OverlayRenderer.h>

                    +#endif

                    +

                     namespace android {

                     enum {

                    @@ -35,7 +38,10 @@ enum {

                         DECODE_FD,

                         CREATE_MEDIA_RECORDER,

                         CREATE_METADATA_RETRIEVER,

                    -    GET_OMX

                    +    GET_OMX,

                    +#ifdef OMAP_ENHANCEMENT

                    +    GET_OVERLAY_RENDERER,

                    +#endif

                     };

                     class BpMediaPlayerService: public BpInterface<IMediaPlayerService>

                    @@ -139,6 +145,15 @@ public:

                             remote()->transact(GET_OMX, data, &reply);

                             return interface_cast<IOMX>(reply.readStrongBinder());

                         }

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual sp<IOverlayRenderer> getOverlayRenderer() {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(IMediaPlayerService::getInterfaceDescriptor());

                    +        remote()->transact(GET_OVERLAY_RENDERER, data, &reply);

                    +        return interface_cast<IOverlayRenderer>(reply.readStrongBinder());

                    +    }

                    +#endif

                     };

                     IMPLEMENT_META_INTERFACE(MediaPlayerService, "android.media.IMediaPlayerService");

                    @@ -232,6 +247,14 @@ status_t BnMediaPlayerService::onTransact(

                                 reply->writeStrongBinder(omx->asBinder());

                                 return NO_ERROR;

                             } break;

                    +#ifdef OMAP_ENHANCEMENT

                    +        case GET_OVERLAY_RENDERER: {

                    +            CHECK_INTERFACE(IMediaPlayerService, data, reply);

                    +            sp<IOverlayRenderer> renderer = getOverlayRenderer();

                    +            reply->writeStrongBinder(renderer->asBinder());

                    +            return NO_ERROR;

                    +        } break;

                    +#endif

                             default:

                                 return BBinder::onTransact(code, data, reply, flags);

                         }

media/libmedia/IOMX.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -29,9 +29,15 @@ enum {

                         EMPTY_BUFFER,

                         GET_EXTENSION_INDEX,

                         CREATE_RENDERER,

                    +#ifdef OMAP_ENHANCEMENT

                    +    CREATE_RENDERER_S3D,

                    +#endif

                         OBSERVER_ON_MSG,

                         RENDERER_RENDER,

                    -    REGISTER_BUFFERS

                    +    REGISTER_BUFFERS,

                    +#ifdef OMAP_ENHANCEMENT

                    +    GET_BUFFERS,

                    +#endif

                     };

                     sp<IOMXRenderer> IOMX::createRenderer(

                    @@ -48,6 +54,20 @@ sp<IOMXRenderer> IOMX::createRenderer(

                                 rotationDegrees);

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +sp<IOMXRenderer> IOMX::createRenderer(

                    +        const sp<Surface> &surface,

                    +        const char *componentName,

                    +        OMX_COLOR_FORMATTYPE colorFormat,

                    +        size_t encodedWidth, size_t encodedHeight,

                    +        size_t displayWidth, size_t displayHeight, int32_t rotate, int isS3D, int numOfOpBuffers) {

                    +    return createRenderer(

                    +            surface->getISurface(),

                    +            componentName, colorFormat, encodedWidth, encodedHeight,

                    +            displayWidth, displayHeight, rotate, isS3D, numOfOpBuffers);

                    +}

                    +#endif

                    +

                     sp<IOMXRenderer> IOMX::createRendererFromJavaSurface(

                             JNIEnv *env, jobject javaSurface,

                             const char *componentName,

                    @@ -221,14 +241,31 @@ public:

                             return reply.readInt32();

                         }

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                         virtual status_t useBuffer(

                                 node_id node, OMX_U32 port_index, const sp<IMemory> &params,

                                 buffer_id *buffer) {

                    +        return useBuffer(node, port_index, params, buffer, 0);

                    +    }

                    +#endif

                    +

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    virtual status_t useBuffer(

                    +            node_id node, OMX_U32 port_index, const sp<IMemory> &params,

                    +            buffer_id *buffer, size_t size) {

                    +#else

                    +    virtual status_t useBuffer(

                    +            node_id node, OMX_U32 port_index, const sp<IMemory> &params,

                    +            buffer_id *buffer) {

                    +#endif

                             Parcel data, reply;

                             data.writeInterfaceToken(IOMX::getInterfaceDescriptor());

                             data.writeIntPtr((intptr_t)node);

                             data.writeInt32(port_index);

                             data.writeStrongBinder(params->asBinder());

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +        data.writeInt32(size);

                    +#endif

                             remote()->transact(USE_BUFFER, data, &reply);

                             status_t err = reply.readInt32();

                    @@ -372,6 +409,33 @@ public:

                             return interface_cast<IOMXRenderer>(reply.readStrongBinder());

                         }

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual sp<IOMXRenderer> createRenderer(

                    +            const sp<ISurface> &surface,

                    +            const char *componentName,

                    +            OMX_COLOR_FORMATTYPE colorFormat,

                    +            size_t encodedWidth, size_t encodedHeight,

                    +            size_t displayWidth, size_t displayHeight, int32_t rotationDegrees, int isS3D, int numOfOpBuffers) {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(IOMX::getInterfaceDescriptor());

                    +        data.writeStrongBinder(surface->asBinder());

                    +        data.writeCString(componentName);

                    +        data.writeInt32(colorFormat);

                    +        data.writeInt32(encodedWidth);

                    +        data.writeInt32(encodedHeight);

                    +        data.writeInt32(displayWidth);

                    +        data.writeInt32(displayHeight);

                    +        data.writeInt32(rotationDegrees);

                    +  data.writeInt32(isS3D);

                    +        data.writeInt32(numOfOpBuffers);

                    +

                    +        remote()->transact(CREATE_RENDERER_S3D, data, &reply);

                    +

                    +        return interface_cast<IOMXRenderer>(reply.readStrongBinder());

                    +    }

                    +#endif

                    +

                     };

                     IMPLEMENT_META_INTERFACE(OMX, "android.hardware.IOMX");

                    @@ -558,7 +622,12 @@ status_t BnOMX::onTransact(

                                     interface_cast<IMemory>(data.readStrongBinder());

                                 buffer_id buffer;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +            OMX_U32 size = data.readInt32();

                    +            status_t err = useBuffer(node, port_index, params, &buffer, size);

                    +#else

                                 status_t err = useBuffer(node, port_index, params, &buffer);

                    +#endif

                                 reply->writeInt32(err);

                                 if (err == OK) {

                    @@ -702,6 +771,37 @@ status_t BnOMX::onTransact(

                                 return OK;

                             }

                    +#ifdef OMAP_ENHANCEMENT

                    +  case CREATE_RENDERER_S3D:

                    +        {

                    +            CHECK_INTERFACE(IOMX, data, reply);

                    +

                    +            sp<ISurface> isurface =

                    +                interface_cast<ISurface>(data.readStrongBinder());

                    +

                    +            const char *componentName = data.readCString();

                    +

                    +            OMX_COLOR_FORMATTYPE colorFormat =

                    +                static_cast<OMX_COLOR_FORMATTYPE>(data.readInt32());

                    +

                    +            size_t encodedWidth = (size_t)data.readInt32();

                    +            size_t encodedHeight = (size_t)data.readInt32();

                    +            size_t displayWidth = (size_t)data.readInt32();

                    +            size_t displayHeight = (size_t)data.readInt32();

                    +            int32_t rotationDegrees = data.readInt32();

                    +            size_t isS3D = (size_t)data.readInt32();

                    +            int numOfOpBuffers = (int)data.readInt32();

                    +

                    +            sp<IOMXRenderer> renderer =

                    +                createRenderer(isurface, componentName, colorFormat,

                    +                               encodedWidth, encodedHeight,

                    +                               displayWidth, displayHeight, rotationDegrees, isS3D, numOfOpBuffers);

                    +            reply->writeStrongBinder(renderer->asBinder());

                    +

                    +            return OK;

                    +        }

                    +#endif

                    +

                             default:

                                 return BBinder::onTransact(code, data, reply, flags);

                         }

                    @@ -748,6 +848,7 @@ status_t BnOMXObserver::onTransact(

                                 return NO_ERROR;

                             }

                    +#ifndef OMAP_ENHANCEMENT

                             case REGISTER_BUFFERS:

                             {

                                 CHECK_INTERFACE(IOMXObserver, data, reply);

                    @@ -755,6 +856,7 @@ status_t BnOMXObserver::onTransact(

                                    interface_cast<IMemoryHeap>(data.readStrongBinder());

                                 registerBuffers(mem);

                             }

                    +#endif

                             default:

                                 return BBinder::onTransact(code, data, reply, flags);

                    @@ -778,6 +880,30 @@ public:

                             // so that the caller knows when to recycle the buffer.

                             remote()->transact(RENDERER_RENDER, data, &reply);

                         }

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual Vector< sp<IMemory> > getBuffers(){

                    +        int n = 0;

                    +        Vector< sp<IMemory> > mMem;

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(IOMXRenderer::getInterfaceDescriptor());

                    +

                    +        status_t err = remote()->transact(GET_BUFFERS, data, &reply);

                    +        n = reply.readInt32();

                    +        for (int i=0;i < n; i++) {

                    +            sp<IMemory> mem = interface_cast<IMemory>(reply.readStrongBinder());

                    +            mMem.add(mem);

                    +        }

                    +        return mMem;

                    +    }

                    +

                    +    virtual bool setCallback(release_rendered_buffer_callback cb, void *cookie) {return false;}

                    +

                    +    virtual void set_s3d_frame_layout(uint32_t s3d_mode, uint32_t s3d_fmt, uint32_t s3d_order, uint32_t s3d_subsampling) {}

                    +    virtual void resizeRenderer(void* resize_params) {}

                    +    virtual void requestRendererClone(bool enable) {}

                    +#endif

                    +

                     };

                     IMPLEMENT_META_INTERFACE(OMXRenderer, "android.hardware.IOMXRenderer");

                    @@ -796,6 +922,20 @@ status_t BnOMXRenderer::onTransact(

                                 return NO_ERROR;

                             }

                    +#ifdef OMAP_ENHANCEMENT

                    +        case GET_BUFFERS:

                    +        {

                    +            LOGV("<<<<< onTransact GET_BUFFERS");

                    +            CHECK_INTERFACE(IOMXRenderer, data, reply);

                    +            Vector< sp<IMemory> > mMem = getBuffers();

                    +            const size_t N = mMem.size();

                    +            reply->writeInt32(N);

                    +            for (size_t i=0; i<N; i++) {

                    +                reply->writeStrongBinder(mMem[i]->asBinder());

                    +            }

                    +            return NO_ERROR;

                    +        }

                    +#endif

                             default:

                                 return BBinder::onTransact(code, data, reply, flags);

                         }

media/libmedia/MediaProfiles.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -52,6 +52,10 @@ const MediaProfiles::NameToTagMap MediaProfiles::sFileFormatMap[] = {

                     const MediaProfiles::NameToTagMap MediaProfiles::sVideoDecoderNameMap[] = {

                         {"wmv", VIDEO_DECODER_WMV}

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    , {"vp6", VIDEO_DECODER_VP6}

                    +    , {"vp7", VIDEO_DECODER_VP7}

                    +#endif

                     };

                     const MediaProfiles::NameToTagMap MediaProfiles::sAudioDecoderNameMap[] = {

media/libmedia/OverlayRenderer.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -0,0 +1,608 @@

                    +/*

                    + * Copyright (C) Texas Instruments - http://www.ti.com/

                    + *

                    + * This library is free software; you can redistribute it and/or

                    + * modify it under the terms of the GNU Lesser General Public

                    + * License as published by the Free Software Foundation; either

                    + * version 2.1 of the License, or (at your option) any later version.

                    + *

                    + *

                    + * This library is distributed in the hope that it will be useful,

                    + * but WITHOUT ANY WARRANTY; without even the implied warranty of

                    + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

                    + * Lesser General Public License for more details.

                    + *

                    + *

                    + * You should have received a copy of the GNU Lesser General Public

                    + * License along with this library; if not, write to the Free Software

                    + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

                    + */

                    +

                    +//#define LOG_NDEBUG 0

                    +#define LOG_TAG "OverlayRenderer"

                    +#include <media/OverlayRenderer.h>

                    +

                    +#define ARMPAGESIZE 4096

                    +#define BOOL_STR(val)  ( (val) ? "TRUE" : "FALSE")

                    +

                    +#define LOG_FUNCTION_NAME_ENTRY    LOGV(" ###### Calling %s() Line %d PID %d ++ ######",  __FUNCTION__, __LINE__, getpid());

                    +#define LOG_FUNCTION_NAME_EXIT    LOGV(" ###### Calling %s() -- ######",  __FUNCTION__);

                    +

                    +//#define __DUMP_TO_FILE__

                    +#ifdef __DUMP_TO_FILE__

                    +#define NUM_BUFFERS_TO_DUMP 46

                    +#define FIRST_FRAME_INDEX 23

                    +FILE *pOutFile;

                    +#endif

                    +

                    +using namespace android;

                    +

                    +namespace android{

                    +

                    +/*

                    +  * Test is a friend class of Surface Control, and hence has access

                    +  * getISurface() method.

                    +  * TODO: The test class is 'added' by TI as a friend. Need to add

                    +  * TIFlashRenderer as a 'friend' to get the ISurface.

                    +  */

                    +class Test {

                    +        public:

                    +            static const sp<ISurface>& getISurface(const sp<SurfaceControl>& s) {

                    +                return s->getISurface();

                    +            }

                    +    };

                    +

                    +#ifdef __DUMP_TO_FILE__

                    +

                    +void dumpBufferToFile(void* pSrc, uint32_t x, uint32_t y, uint32_t w, uint32_t h, uint32_t s)

                    +{

                    +    //LOGD("framenumber = %u, pSrc = %p, x = %u, y = %u, w = %u, h = %u, s = %u", framenumber, pSrc, x, y, w, h, s);

                    +    /* Dumping only the Y component */

                    +    pSrc = pSrc + (y*s);

                    +    for (int i = 0; i < h; i++) {

                    +        fwrite(pSrc+x, 1, w, pOutFile);

                    +        fflush(pOutFile);

                    +        pSrc = pSrc + s;

                    +    }

                    +}

                    +

                    +#endif

                    +

                    +OverlayRenderer::OverlayRenderer()

                    +{

                    +    LOG_FUNCTION_NAME_ENTRY

                    +}

                    +

                    +OverlayRenderer::~OverlayRenderer()

                    +{

                    +    LOG_FUNCTION_NAME_ENTRY

                    +}

                    +

                    +int32_t OverlayRenderer::createOverlayRenderer(uint32_t bufferCount,

                    +                                int32_t displayWidth,

                    +                                int32_t displayHeight,

                    +                                uint32_t colorFormat,

                    +                                int32_t decodedWidth,

                    +                                int32_t decodedHeight,

                    +                                int infoType,

                    +                                void * info)

                    +{

                    +    LOG_FUNCTION_NAME_ENTRY

                    +

                    +    mBufferCount = bufferCount;

                    +    mDisplayWidth = displayWidth;

                    +    mDisplayHeight = displayHeight;

                    +    mColorFormat = colorFormat;

                    +    mDecodedWidth = decodedWidth;

                    +    mDecodedHeight = decodedHeight;

                    +    mInfoType = infoType;

                    +    //Keep in mind that info ptr is NOT passed across in BpOverlayRenderer

                    +

                    +    mInitCheck = NO_INIT;

                    +

                    +    /* Create required surfaces and overlay objects */

                    +    if(OK != createSurface()){

                    +        LOGE("Failed to create Surface");

                    +        goto EXIT;

                    +    }

                    +

                    +    /* creating buffers */

                    +    if(OK != createBuffers()) {

                    +        LOGE("Failed to create Buffers");

                    +        goto EXIT;

                    +    }

                    +

                    +    mInitCheck = OK;

                    +

                    +#ifdef __DUMP_TO_FILE__

                    +

                    +    char filename[100];

                    +    sprintf(filename, "/sdcard/framedump_%dx%d.yuv", mDisplayWidth, mDisplayHeight);

                    +    pOutFile = fopen(filename, "wb");

                    +    if(pOutFile == NULL)

                    +        LOGE("\n!!!!!!!!!!!!!!!!Error opening file %s !!!!!!!!!!!!!!!!!!!!", filename);

                    +

                    +#endif

                    +

                    +EXIT:

                    +

                    +    return mInitCheck;

                    +}

                    +

                    +void OverlayRenderer::releaseMe()

                    +{

                    +    //delete this;

                    +

                    +    LOG_FUNCTION_NAME_ENTRY

                    +

                    +    if ( NULL != mOverlay.get() ) {

                    +        mOverlay->destroy();

                    +        mOverlay.clear();

                    +    }

                    +

                    +    //if ( NULL != mOverlayRef.get() )

                    +    {

                    +        //mOverlayRef = 0;

                    +    }

                    +

                    +    if ( NULL != mISurface.get() ) {

                    +        mISurface.clear();

                    +    }

                    +

                    +    if ( NULL != mSurfaceControl.get() ) {

                    +        mSurfaceControl->clear();

                    +        mSurfaceControl.clear();

                    +    }

                    +

                    +    if ( NULL != mSurfaceClient.get() ) {

                    +        mSurfaceClient->dispose();

                    +        mSurfaceClient.clear();

                    +    }

                    +

                    +

                    +    /* TODO: make sure all other resources are released as well */

                    +

                    +#ifdef __DUMP_TO_FILE__

                    +        if (pOutFile) fclose(pOutFile);

                    +#endif

                    +

                    +}

                    +

                    +sp<IMemory> OverlayRenderer::getBuffer(uint32_t index)

                    +{

                    +    if (index >= mBufferCount) index = 0;

                    +    return mOverlayAddresses[index];

                    +}

                    +

                    +int32_t OverlayRenderer::createBuffers()

                    +{

                    +    LOG_FUNCTION_NAME_ENTRY

                    +

                    +    mapping_data_t *data;

                    +    sp<IMemory> mem;

                    +

                    +    /* check if the overlay created required number of buffers for decoder */

                    +    if (mBufferCount != (uint32_t)mOverlay->getBufferCount() ) {

                    +        mOverlay->setParameter(OVERLAY_NUM_BUFFERS, mBufferCount);

                    +        mOverlay->resizeInput(mDecodedWidth, mDecodedHeight);

                    +    }

                    +

                    +    /* TODO: Optimal buffer count now 2. Confirm?? */

                    +    mOverlay->setParameter(OPTIMAL_QBUF_CNT, 4);

                    +

                    +    for (size_t bCount = 0; bCount < mBufferCount; ++bCount) {

                    +        data = (mapping_data_t *)mOverlay->getBufferAddress((void *)bCount);

                    +        CHECK(data != NULL);

                    +

                    +        mVideoHeaps[bCount] = new MemoryHeapBase(data->fd,data->length, 0, data->offset);

                    +        mem = new MemoryBase(mVideoHeaps[bCount], 0, data->length);

                    +        CHECK(mem.get() != NULL);

                    +

                    +        LOGV("data->fd %d, data->length =%d, data->offset =%x, mem->pointer[%d] = %p", data->fd,data->length, data->offset, bCount, mem->pointer());

                    +

                    +        mOverlayAddresses.push(mem);

                    +    }

                    +

                    +    return OK;

                    +}

                    +

                    +

                    +int32_t OverlayRenderer::createSurface()

                    +{

                    +    LOG_FUNCTION_NAME_ENTRY

                    +

                    +    if(mOverlay.get() == NULL){

                    +

                    +        mSurfaceClient = new SurfaceComposerClient();

                    +

                    +        if ( NULL == mSurfaceClient.get() ) {

                    +            LOGE("Unable to establish connection to Surface Composer \n");

                    +            return UNKNOWN_ERROR;

                    +        }

                    +

                    +        mSurfaceControl = mSurfaceClient->createSurface(getpid(), 0, mDecodedWidth, mDecodedHeight,

                    +                           PIXEL_FORMAT_UNKNOWN, ISurfaceComposer::ePushBuffers);

                    +

                    +        if ( NULL == mSurfaceControl.get() ) {

                    +            LOGE("Unable to create Overlay control surface\n");

                    +            return UNKNOWN_ERROR;

                    +        }

                    +

                    +        mISurface = Test::getISurface(mSurfaceControl);

                    +        if ( NULL == mISurface.get() ) {

                    +            LOGE("Unable to get overlay ISurface interface\n");

                    +            return UNKNOWN_ERROR;

                    +        }

                    +

                    +        sp<OverlayRef> ref = mISurface->createOverlay(mDecodedWidth, mDecodedHeight, mColorFormat, 0);

                    +        if (ref.get() == NULL) {

                    +            LOGE("Unable to create Overlay Reference\n");

                    +            return UNKNOWN_ERROR;

                    +        }

                    +

                    +        //Create Overlay Object

                    +        mOverlay = new Overlay(ref);

                    +

                    +        if(mOverlay.get() == NULL) {

                    +            LOGE("Unable to create Overlay Object\n");

                    +            return UNKNOWN_ERROR;

                    +        }

                    +

                    +        /* Configuring the surface */

                    +        mSurfaceClient->openTransaction();

                    +        mSurfaceControl->setLayer(100000);

                    +        //mSurfaceControl->setLayer(0x40000000);set in BootAnimation.cpp

                    +        mSurfaceClient->closeTransaction();

                    +

                    +    }

                    +    return OK;

                    +

                    +}

                    +

                    +int32_t OverlayRenderer::dequeueBuffer(uint32_t *index)

                    +{

                    +    return mOverlay->dequeueBuffer((overlay_buffer_t*)index);

                    +}

                    +

                    +int32_t OverlayRenderer::queueBuffer(uint32_t index)

                    +{

                    +

                    +#ifdef __DUMP_TO_FILE__

                    +    static int displaycount = 0;

                    +    static int lastframetodump = FIRST_FRAME_INDEX+NUM_BUFFERS_TO_DUMP;

                    +

                    +    if ((displaycount >= FIRST_FRAME_INDEX)  && (displaycount < lastframetodump)){

                    +        //dumpBufferToFile(mediaBuf->data(), mCropX, mCropY, mDisplayWidth, mDisplayHeight, 4096);

                    +    }

                    +    displaycount++;

                    +

                    +#endif

                    +

                    +    return mOverlay->queueBuffer((void *)index);

                    +}

                    +

                    +int32_t OverlayRenderer::setCrop(uint32_t x, uint32_t y, uint32_t w, uint32_t h)

                    +{

                    +    return mOverlay->setCrop(x, y, w, h);

                    +}

                    +

                    +int32_t OverlayRenderer::setPosition(int32_t x, int32_t y)

                    +{

                    +    win_x = x;

                    +    win_y = y;

                    +    mSurfaceClient->openTransaction();

                    +    mSurfaceControl->setPosition(win_x, win_y);

                    +    mSurfaceClient->closeTransaction();

                    +

                    +    return OK;

                    +}

                    +

                    +int32_t OverlayRenderer::setSize(uint32_t w, uint32_t h)

                    +{

                    +    mSurfaceClient->openTransaction();

                    +    mSurfaceControl->setSize(w, h);

                    +    mSurfaceClient->closeTransaction();

                    +

                    +    /* I am changing Position too bcos just a change in size is not recognized by surface flinger. */

                    +

                    +    /* In LayerBase::setPosition(), the sequence no. is incremented. But the same is not done

                    +        for LayerBase::setSize(). It is this change in sequence no. which triggers

                    +        LayerBuffer::OverlaySource::onTransaction() which triggers

                    +        LayerBuffer::OverlaySource::onVisibilityResolved() which triggers

                    +        overlay_dev->setPosition()

                    +    */

                    +

                    +    mSurfaceClient->openTransaction();

                    +    mSurfaceControl->setPosition(1, 1);

                    +    mSurfaceClient->closeTransaction();

                    +

                    +    mSurfaceClient->openTransaction();

                    +    mSurfaceControl->setPosition(win_x, win_y);

                    +    mSurfaceClient->closeTransaction();

                    +

                    +    return OK;

                    +}

                    +

                    +int32_t OverlayRenderer::setOrientation(int32_t orientation, uint32_t flags)

                    +{

                    +    mSurfaceClient->openTransaction();

                    +    switch(orientation)

                    +        {

                    +        case 0:

                    +            mSurfaceClient->setOrientation(0,ISurfaceComposer::eOrientationDefault,0);

                    +            break;

                    +        case 90:

                    +            mSurfaceClient->setOrientation(0,ISurfaceComposer::eOrientation90,0);

                    +            break;

                    +        case 180:

                    +            mSurfaceClient->setOrientation(0,ISurfaceComposer::eOrientation180,0);

                    +            break;

                    +        case 270:

                    +            mSurfaceClient->setOrientation(0,ISurfaceComposer::eOrientation270,0);

                    +            break;

                    +        default:

                    +            LOGD("Rotation not applied. Illegal Value");

                    +        };

                    +

                    +    mSurfaceClient->closeTransaction();

                    +    return OK;

                    +}

                    +

                    +////////////////////////////////////////////////////////////////////////////////

                    +

                    +enum {

                    +    CREATE_OVERLAY_RENDERER,

                    +    RELEASE,

                    +    GET_BUFFER_COUNT,

                    +    GET_BUFFER,

                    +    DEQUEUE_BUFFER,

                    +    QUEUE_BUFFER,

                    +    SET_ORIENTATION,

                    +    SET_POSITION,

                    +    SET_SIZE,

                    +    SET_CROP

                    +};

                    +

                    +

                    +

                    +class BpOverlayRenderer : public BpInterface<IOverlayRenderer> {

                    +public:

                    +    BpOverlayRenderer(const sp<IBinder> &impl)

                    +        : BpInterface<IOverlayRenderer>(impl) {

                    +    }

                    +

                    +    virtual int32_t createOverlayRenderer(

                    +        uint32_t bufferCount, int32_t displayWidth,  int32_t displayHeight,

                    +        uint32_t colorFormat, int32_t decodedWidth, int32_t decodedHeight,

                    +        int infoType, void * info)

                    +    {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(IOverlayRenderer::getInterfaceDescriptor());

                    +        data.writeInt32(bufferCount);

                    +        data.writeInt32(displayWidth);

                    +        data.writeInt32(displayHeight);

                    +        data.writeInt32(colorFormat);

                    +        data.writeInt32(decodedWidth);

                    +        data.writeInt32(decodedHeight);

                    +        data.writeInt32(infoType);

                    +        remote()->transact(CREATE_OVERLAY_RENDERER, data, &reply);

                    +        return reply.readInt32();

                    +    }

                    +

                    +    virtual void releaseMe()

                    +    {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(IOverlayRenderer::getInterfaceDescriptor());

                    +        remote()->transact(RELEASE, data, &reply);

                    +    }

                    +

                    +    virtual uint32_t getBufferCount()

                    +    {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(IOverlayRenderer::getInterfaceDescriptor());

                    +        remote()->transact(GET_BUFFER_COUNT, data, &reply);

                    +        return reply.readInt32();

                    +    }

                    +

                    +    virtual sp<IMemory> getBuffer(uint32_t index)

                    +    {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(IOverlayRenderer::getInterfaceDescriptor());

                    +        data.writeInt32(index);

                    +        remote()->transact(GET_BUFFER, data, &reply);

                    +        sp<IMemory> params = interface_cast<IMemory>(reply.readStrongBinder());

                    +        return params;

                    +    }

                    +

                    +    virtual int32_t dequeueBuffer(uint32_t *index)

                    +    {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(IOverlayRenderer::getInterfaceDescriptor());

                    +        remote()->transact(DEQUEUE_BUFFER, data, &reply);

                    +        int32_t err = reply.readInt32();

                    +        *index = reply.readInt32();

                    +        return err;

                    +    }

                    +

                    +    virtual int32_t queueBuffer(uint32_t index)

                    +    {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(IOverlayRenderer::getInterfaceDescriptor());

                    +        data.writeInt32(index);

                    +        remote()->transact(QUEUE_BUFFER, data, &reply);

                    +        return reply.readInt32();

                    +    }

                    +

                    +    virtual int32_t setOrientation(int32_t orientation, uint32_t flags)

                    +    {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(IOverlayRenderer::getInterfaceDescriptor());

                    +        data.writeInt32(orientation);

                    +        data.writeInt32(flags);

                    +        remote()->transact(SET_ORIENTATION, data, &reply);

                    +        return reply.readInt32();

                    +    }

                    +

                    +    virtual int32_t setPosition(int32_t x, int32_t y)

                    +    {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(IOverlayRenderer::getInterfaceDescriptor());

                    +        data.writeInt32(x);

                    +        data.writeInt32(y);

                    +        remote()->transact(SET_POSITION, data, &reply);

                    +        return reply.readInt32();

                    +    }

                    +

                    +    virtual int32_t setSize(uint32_t w, uint32_t h)

                    +    {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(IOverlayRenderer::getInterfaceDescriptor());

                    +        data.writeInt32(w);

                    +        data.writeInt32(h);

                    +        remote()->transact(SET_SIZE, data, &reply);

                    +        return reply.readInt32();

                    +    }

                    +

                    +    virtual int32_t setCrop(uint32_t x, uint32_t y, uint32_t w, uint32_t h)

                    +    {

                    +        Parcel data, reply;

                    +        data.writeInterfaceToken(IOverlayRenderer::getInterfaceDescriptor());

                    +        data.writeInt32(x);

                    +        data.writeInt32(y);

                    +        data.writeInt32(w);

                    +        data.writeInt32(h);

                    +        remote()->transact(SET_CROP, data, &reply);

                    +        return reply.readInt32();

                    +    }

                    +

                    +};

                    +

                    +IMPLEMENT_META_INTERFACE(OverlayRenderer, "android.media.IOverlayRenderer");

                    +

                    +status_t BnOverlayRenderer::onTransact(

                    +    uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags) {

                    +

                    +    switch (code) {

                    +

                    +        case CREATE_OVERLAY_RENDERER:

                    +        {

                    +            CHECK_INTERFACE(IOverlayRenderer, data, reply);

                    +            uint32_t bufferCount = data.readInt32();

                    +            int32_t displayWidth = data.readInt32();

                    +            int32_t displayHeight = data.readInt32();

                    +            uint32_t colorFormat = data.readInt32();

                    +            int32_t decodedWidth = data.readInt32();

                    +            int32_t decodedHeight = data.readInt32();

                    +            int infoType = data.readInt32();

                    +            void *info;

                    +            reply->writeInt32(createOverlayRenderer(bufferCount, displayWidth, displayHeight, colorFormat, decodedWidth, decodedHeight, infoType, info));

                    +

                    +            return NO_ERROR;

                    +        }

                    +

                    +        case RELEASE:

                    +        {

                    +            CHECK_INTERFACE(IOverlayRenderer, data, reply);

                    +            releaseMe();

                    +            return NO_ERROR;

                    +        }

                    +

                    +        case GET_BUFFER_COUNT:

                    +        {

                    +            CHECK_INTERFACE(IOverlayRenderer, data, reply);

                    +

                    +            uint32_t count = getBufferCount();

                    +            reply->writeInt32(count);

                    +

                    +            return NO_ERROR;

                    +        }

                    +

                    +        case GET_BUFFER:

                    +        {

                    +            CHECK_INTERFACE(IOverlayRenderer, data, reply);

                    +

                    +            int32_t index = data.readInt32();

                    +

                    +            sp<IMemory> params  = getBuffer(index);

                    +            reply->writeStrongBinder(params->asBinder());

                    +

                    +            return NO_ERROR;

                    +        }

                    +

                    +        case DEQUEUE_BUFFER:

                    +        {

                    +            CHECK_INTERFACE(IOverlayRenderer, data, reply);

                    +

                    +            uint32_t index;

                    +

                    +            int32_t err = dequeueBuffer(&index);

                    +            reply->writeInt32(err);

                    +            reply->writeInt32(index);

                    +            return NO_ERROR;

                    +        }

                    +

                    +        case QUEUE_BUFFER:

                    +        {

                    +            CHECK_INTERFACE(IOverlayRenderer, data, reply);

                    +

                    +            int32_t index = data.readInt32();

                    +

                    +            reply->writeInt32(queueBuffer(index));

                    +            return NO_ERROR;

                    +        }

                    +

                    +        case SET_ORIENTATION:

                    +        {

                    +            CHECK_INTERFACE(IOverlayRenderer, data, reply);

                    +

                    +            uint32_t orientation = data.readInt32();

                    +            uint32_t flags = data.readInt32();

                    +

                    +            reply->writeInt32(setOrientation(orientation, flags));

                    +            return NO_ERROR;

                    +        }

                    +

                    +        case SET_POSITION:

                    +        {

                    +            CHECK_INTERFACE(IOverlayRenderer, data, reply);

                    +

                    +            uint32_t x = data.readInt32();

                    +            uint32_t y = data.readInt32();

                    +

                    +            reply->writeInt32(setPosition(x, y));

                    +            return NO_ERROR;

                    +        }

                    +

                    +        case SET_SIZE:

                    +        {

                    +            CHECK_INTERFACE(IOverlayRenderer, data, reply);

                    +

                    +            uint32_t w = data.readInt32();

                    +            uint32_t h = data.readInt32();

                    +

                    +            reply->writeInt32(setSize(w, h));

                    +            return NO_ERROR;

                    +        }

                    +

                    +        case SET_CROP:

                    +        {

                    +            CHECK_INTERFACE(IOverlayRenderer, data, reply);

                    +

                    +            uint32_t x = data.readInt32();

                    +            uint32_t y = data.readInt32();

                    +            uint32_t w = data.readInt32();

                    +            uint32_t h = data.readInt32();

                    +

                    +            reply->writeInt32(setCrop(x, y, w, h));

                    +            return NO_ERROR;

                    +        }

                    +

                    +        default:

                    +            return BBinder::onTransact(code, data, reply, flags);

                    +    }

                    +}

                    +

                    +

                    +

                    +}

                    +

media/libmedia/mediaplayer.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -504,6 +504,18 @@ status_t MediaPlayer::setVolume(float leftVolume, float rightVolume)

                         return OK;

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +status_t MediaPlayer::requestVideoCloneMode(bool enable)

                    +{

                    +    Mutex::Autolock _l(mLock);

                    +    if (mPlayer != NULL) {

                    +        return mPlayer->requestVideoCloneMode(enable);

                    +    }

                    +    return OK;

                    +}

                    +

                    +#endif

                    +

                     status_t MediaPlayer::setAudioSessionId(int sessionId)

                     {

                         LOGV("MediaPlayer::setAudioSessionId(%d)", sessionId);

media/libmediaplayerservice/Android.mk

show inline notes
View file @ 1a6862f

            
                    @@ -71,6 +71,14 @@ ifeq ($(strip $(BOARD_USES_HW_MEDIAPLUGINS)),true)

                         LOCAL_CFLAGS += -DUSE_BOARD_MEDIAPLUGIN

                     endif

                    +ifeq ($(OMAP_ENHANCEMENT),true)

                    +

                    +LOCAL_C_INCLUDES += $(TOP)/hardware/ti/omap3/liboverlay

                    +

                    +LOCAL_SHARED_LIBRARIES += libui

                    +

                    +endif

                    +

                     LOCAL_MODULE:= libmediaplayerservice

                     include $(BUILD_SHARED_LIBRARY)

media/libmediaplayerservice/MediaPlayerService.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -62,6 +62,9 @@

                     #include "StagefrightPlayer.h"

                     #include <OMX.h>

                    +#ifdef OMAP_ENHANCEMENT

                    +#include <media/OverlayRenderer.h>

                    +#endif

                     #ifdef USE_BOARD_MEDIAPLUGIN

                     #define NO_OPENCORE 1

                    @@ -203,6 +206,11 @@ extmap FILE_EXTS [] =  {

                             {".rtttl", SONIVOX_PLAYER},

                             {".rtx", SONIVOX_PLAYER},

                             {".ota", SONIVOX_PLAYER},

                    +#ifdef OMAP_ENHANCEMENT

                    +        {".wma", STAGEFRIGHT_PLAYER},

                    +        {".wmv", STAGEFRIGHT_PLAYER},

                    +        {".asf", STAGEFRIGHT_PLAYER},

                    +#else

                     #ifdef USE_BOARD_MEDIAPLUGIN

                             {".ogg", STAGEFRIGHT_PLAYER},

                     #endif

                    @@ -211,6 +219,7 @@ extmap FILE_EXTS [] =  {

                             {".wmv", PV_PLAYER},

                             {".asf", PV_PLAYER},

                     #endif

                    +#endif

                             {".flac", FLAC_PLAYER},

                     };

                    @@ -305,6 +314,18 @@ sp<IOMX> MediaPlayerService::getOMX() {

                         return mOMX;

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +sp<IOverlayRenderer> MediaPlayerService::getOverlayRenderer() {

                    +    Mutex::Autolock autoLock(mLock);

                    +

                    +    if (mOverlayRenderer.get() == NULL) {

                    +        mOverlayRenderer = new OverlayRenderer;

                    +    }

                    +

                    +    return mOverlayRenderer;

                    +}

                    +#endif

                    +

                     status_t MediaPlayerService::AudioCache::dump(int fd, const Vector<String16>& args) const

                     {

                         const size_t SIZE = 256;

                    @@ -705,6 +726,13 @@ player_type getPlayerType(int fd, int64_t offset, int64_t length)

                         if (ident == 0x5367674f) // 'OggS'

                             return STAGEFRIGHT_PLAYER;

                    +#ifdef OMAP_ENHANCEMENT

                    +    if (ident == 0x75b22630) {

                    +        LOGV("The magic number for .asf files, i.e. wmv and wma content");

                    +        LOGV("These will be supported through stagefright.");

                    +        return STAGEFRIGHT_PLAYER;

                    +    }

                    +#else

                     #ifndef NO_OPENCORE

                         if (ident == 0x75b22630) {

                             // The magic number for .asf files, i.e. wmv and wma content.

                    @@ -713,9 +741,9 @@ player_type getPlayerType(int fd, int64_t offset, int64_t length)

                         }

                     #endif

                    +#endif

                         if (ident == 0x43614c66) // 'fLaC'

                             return FLAC_PLAYER;

                    -

                         // Some kind of MIDI?

                         EAS_DATA_HANDLE easdata;

                         if (EAS_Init(&easdata) == EAS_SUCCESS) {

                    @@ -1007,6 +1035,16 @@ status_t MediaPlayerService::Client::resume() {

                         return p->resume();

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +status_t MediaPlayerService::Client::requestVideoCloneMode(bool enable) {

                    +    sp<MediaPlayerBase> p = getPlayer();

                    +    if (p == 0) return UNKNOWN_ERROR;

                    +

                    +    return p->requestVideoCloneMode(enable);

                    +}

                    +

                    +#endif

                    +

                     status_t MediaPlayerService::Client::prepareAsync()

                     {

                         LOGV("[%d] prepareAsync", mConnId);

media/libmediaplayerservice/MediaPlayerService.h

show inline notes
View file @ 1a6862f

            
                    @@ -36,6 +36,9 @@ class IMediaRecorder;

                     class IMediaMetadataRetriever;

                     class IOMX;

                     class MediaRecorderClient;

                    +#ifdef OMAP_ENHANCEMENT

                    +class IOverlayRenderer;

                    +#endif

                     #define CALLBACK_ANTAGONIZER 0

                     #if CALLBACK_ANTAGONIZER

                    @@ -194,7 +197,9 @@ public:

                         virtual sp<IMemory>         decode(const char* url, uint32_t *pSampleRate, int* pNumChannels, int* pFormat);

                         virtual sp<IMemory>         decode(int fd, int64_t offset, int64_t length, uint32_t *pSampleRate, int* pNumChannels, int* pFormat);

                         virtual sp<IOMX>            getOMX();

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual sp<IOverlayRenderer>  getOverlayRenderer();

                    +#endif

                         virtual status_t            dump(int fd, const Vector<String16>& args);

                                 void                removeClient(wp<Client> client);

                    @@ -228,6 +233,9 @@ private:

                             virtual status_t        resume();

                             virtual status_t        setAuxEffectSendLevel(float level);

                             virtual status_t        attachAuxEffect(int effectId);

                    +#ifdef OMAP_ENHANCEMENT

                    +        virtual status_t        requestVideoCloneMode(bool enable);

                    +#endif

                             sp<MediaPlayerBase>     createPlayer(player_type playerType);

                    @@ -305,6 +313,9 @@ private:

                                     SortedVector< wp<MediaRecorderClient> > mMediaRecorderClients;

                                     int32_t                     mNextConnId;

                                     sp<IOMX>                    mOMX;

                    +#ifdef OMAP_ENHANCEMENT

                    +                sp<IOverlayRenderer> mOverlayRenderer;

                    +#endif

                     };

                     // ----------------------------------------------------------------------------

media/libmediaplayerservice/StagefrightPlayer.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -150,6 +150,12 @@ status_t StagefrightPlayer::resume() {

                         return mPlayer->resume();

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +status_t StagefrightPlayer::requestVideoCloneMode(bool enable) {

                    +    return mPlayer->requestVideoCloneMode(enable);

                    +}

                    +#endif

                    +

                     status_t StagefrightPlayer::invoke(const Parcel &request, Parcel *reply) {

                         return INVALID_OPERATION;

                     }

media/libmediaplayerservice/StagefrightPlayer.h

show inline notes
View file @ 1a6862f

            
                    @@ -52,6 +52,9 @@ public:

                         virtual void setAudioSink(const sp<AudioSink> &audioSink);

                         virtual status_t suspend();

                         virtual status_t resume();

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual status_t requestVideoCloneMode(bool enable);

                    +#endif

                         virtual status_t getMetadata(

                                 const media::Metadata::Filter& ids, Parcel *records);

media/libmediaplayerservice/StagefrightRecorder.cpp 100644 → 100755

show inline notes
View file @ 1a6862f

            
                    @@ -678,19 +678,6 @@ status_t StagefrightRecorder::start() {

                     }

                     sp<MediaSource> StagefrightRecorder::createAudioSource() {

                    -    sp<AudioSource> audioSource =

                    -        new AudioSource(

                    -                mAudioSource,

                    -                mSampleRate,

                    -                mAudioChannels);

                    -

                    -    status_t err = audioSource->initCheck();

                    -

                    -    if (err != OK) {

                    -        LOGE("audio source is not initialized");

                    -        return NULL;

                    -    }

                    -

                         sp<MetaData> encMeta = new MetaData;

                         const char *mime;

                         switch (mAudioEncoder) {

                    @@ -710,6 +697,22 @@ sp<MediaSource> StagefrightRecorder::createAudioSource() {

                         }

                         encMeta->setCString(kKeyMIMEType, mime);

                    +    mSampleRate = mEncoderProfiles->getAudioEncoderParamByName(

                    +                   "enc.aud.hz.min", mAudioEncoder);

                    +

                    +    sp<AudioSource> audioSource =

                    +        new AudioSource(

                    +                mAudioSource,

                    +                mSampleRate,

                    +                mAudioChannels);

                    +

                    +    status_t err = audioSource->initCheck();

                    +

                    +    if (err != OK) {

                    +        LOGE("audio source is not initialized");

                    +        return NULL;

                    +    }

                    +

                         int32_t maxInputSize;

                         CHECK(audioSource->getFormat()->findInt32(

                                     kKeyMaxInputSize, &maxInputSize));

                    @@ -725,9 +728,24 @@ sp<MediaSource> StagefrightRecorder::createAudioSource() {

                         OMXClient client;

                         CHECK_EQ(client.connect(), OK);

                    -    sp<MediaSource> audioEncoder =

                    +    sp<MediaSource> audioEncoder;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)

                    +#define MAX_RESOLUTION 414720

                    +    if ((mAudioEncoder == AUDIO_ENCODER_AAC) &&

                    +        (mVideoWidth*mVideoHeight > MAX_RESOLUTION)) {

                    +        audioEncoder =

                    +            OMXCodec::Create(client.interface(), encMeta,

                    +                             true /* createEncoder */, audioSource,

                    +                             "OMX.ITTIAM.AAC.encode");

                    +

                    +    } else {

                    +#endif

                    +    audioEncoder =

                             OMXCodec::Create(client.interface(), encMeta,

                                              true /* createEncoder */, audioSource);

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)

                    +    }

                    +#endif

                         mAudioSourceNode = audioSource;

                         return audioEncoder;

                    @@ -901,12 +919,63 @@ void StagefrightRecorder::clipVideoFrameRate() {

                         }

                     }

                    +/* Needs to be check max-bitrate in here to make sure that encoding with right parameters */

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)

                    +

                    +#define ARRAY_SIZE(array) (sizeof array / sizeof array[0])

                    +

                    +typedef struct {

                    +    size_t level;

                    +    size_t maxBitRate;

                    +    size_t maxFrameSizeinMbs;

                    +    size_t maxMbsPerSecond;

                    +} omap3_dsp_h264_supported;

                    +

                    +/* Below table synced with inside codec's */

                    +const omap3_dsp_h264_supported _h264_supported[] = {

                    +                            {10, 64000, 99, 1485},

                    +                            {11, 192000, 396, 3000},

                    +                            {12, 384000, 396, 6000},

                    +                            {20, 2000000, 396, 11880},

                    +                            {21, 4000000, 792, 19800},

                    +                            {22, 4000000, 1620, 20250},

                    +                            {30, 10000000, 1620, 40500}};

                    +

                    +static int _get_maxrate_in_mbs(int width, int height, int fps) {

                    +    int mps = (width / 16) * (height / 16) * fps; /* Max macroblocks per second */

                    +    int i;

                    +    int maxrate = -1;

                    +

                    +    for (i = 0; i < ARRAY_SIZE(_h264_supported); i++) {

                    +        if (mps < _h264_supported[i].maxMbsPerSecond) {

                    +            maxrate = _h264_supported[i].maxBitRate;

                    +            break;

                    +        }

                    +    }

                    +

                    +    // not found, set max.

                    +    if (maxrate == -1) maxrate = _h264_supported[ARRAY_SIZE(_h264_supported)-1].maxBitRate;

                    +

                    +    return maxrate;

                    +}

                    +#endif /* defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3) */

                    +

                     void StagefrightRecorder::clipVideoBitRate() {

                         LOGV("clipVideoBitRate: encoder %d", mVideoEncoder);

                    -    int minBitRate = mEncoderProfiles->getVideoEncoderParamByName(

                    -                        "enc.vid.bps.min", mVideoEncoder);

                    -    int maxBitRate = mEncoderProfiles->getVideoEncoderParamByName(

                    -                        "enc.vid.bps.max", mVideoEncoder);

                    +    int minBitRate;

                    +    int maxBitRate;

                    +

                    +    minBitRate = mEncoderProfiles->getVideoEncoderParamByName(

                    +        "enc.vid.bps.min", mVideoEncoder);

                    +

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)

                    +    if (mVideoEncoder == 2) /* H.264 */

                    +        maxBitRate = _get_maxrate_in_mbs(mVideoWidth, mVideoHeight, mFrameRate);

                    +    else

                    +#endif

                    +        maxBitRate = mEncoderProfiles->getVideoEncoderParamByName(

                    +            "enc.vid.bps.max", mVideoEncoder);

                    +

                         if (mVideoBitRate < minBitRate) {

                             LOGW("Intended video encoding bit rate (%d bps) is too small"

                                  " and will be set to (%d bps)", mVideoBitRate, minBitRate);

                    @@ -1045,6 +1114,18 @@ status_t StagefrightRecorder::setupVideoEncoder(sp<MediaSource> *source) {

                         CHECK(meta->findInt32(kKeyStride, &stride));

                         CHECK(meta->findInt32(kKeySliceHeight, &sliceHeight));

                         CHECK(meta->findInt32(kKeyColorFormat, &colorFormat));

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +    int32_t paddedWidth, paddedHeight, seiEncodingType, mS3DCamera;

                    +    const char *frameLayoutStr;

                    +    CHECK(meta->findInt32(kKeyPaddedWidth, &paddedWidth));

                    +    CHECK(meta->findInt32(kKeyPaddedHeight, &paddedHeight));

                    +    CHECK(meta->findInt32(kKeyS3dSupported, &mS3DCamera));

                    +    if(mS3DCamera)

                    +    {

                    +        CHECK(meta->findInt32(kKeySEIEncodingType, &seiEncodingType));

                    +        CHECK(meta->findCString(kKeyFrameLayout, &frameLayoutStr));

                    +    }

                    +#endif

                         enc_meta->setInt32(kKeyWidth, width);

                         enc_meta->setInt32(kKeyHeight, height);

                    @@ -1052,6 +1133,17 @@ status_t StagefrightRecorder::setupVideoEncoder(sp<MediaSource> *source) {

                         enc_meta->setInt32(kKeyStride, stride);

                         enc_meta->setInt32(kKeySliceHeight, sliceHeight);

                         enc_meta->setInt32(kKeyColorFormat, colorFormat);

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +    enc_meta->setInt32(kKeyPaddedWidth, paddedWidth);

                    +    enc_meta->setInt32(kKeyPaddedHeight, paddedHeight);

                    +    enc_meta->setInt32(kKeyS3dSupported, mS3DCamera);

                    +    if(mS3DCamera)

                    +    {

                    +        enc_meta->setInt32(kKeySEIEncodingType, seiEncodingType);

                    +        enc_meta->setCString(kKeyFrameLayout, frameLayoutStr);

                    +    }

                    +#endif

                    +

                         if (mVideoTimeScale > 0) {

                             enc_meta->setInt32(kKeyTimeScale, mVideoTimeScale);

                         }

                    @@ -1103,12 +1195,14 @@ status_t StagefrightRecorder::startMPEG4Recording() {

                         status_t err = OK;

                         sp<MediaWriter> writer = new MPEG4Writer(dup(mOutputFd));

                    +#if !defined(OMAP_ENHANCEMENT)

                         // Add audio source first if it exists

                         if (mAudioSource != AUDIO_SOURCE_LIST_END) {

                             err = setupAudioEncoder(writer);

                             if (err != OK) return err;

                             totalBitRate += mAudioBitRate;

                         }

                    +#endif

                         if (mVideoSource == VIDEO_SOURCE_DEFAULT

                                 || mVideoSource == VIDEO_SOURCE_CAMERA) {

                             sp<MediaSource> encoder;

                    @@ -1117,6 +1211,16 @@ status_t StagefrightRecorder::startMPEG4Recording() {

                             writer->addSource(encoder);

                             totalBitRate += mVideoBitRate;

                         }

                    +#if defined(OMAP_ENHANCEMENT)

                    +    // Starting Audio after video to fix AV-Sync issue. The AV-Sync issue here refers to lip-sync not achieved in recorded video.

                    +    // This is due to the audio track thread blocking the video thread for approx half a second which results in audio recorded

                    +    // half a second earlier than video. This when played back results in audio/video out of sync.

                    +    if (mAudioSource != AUDIO_SOURCE_LIST_END) {

                    +        err = setupAudioEncoder(writer);

                    +        if (err != OK) return err;

                    +        totalBitRate += mAudioBitRate;

                    +    }

                    +#endif

                         if (mInterleaveDurationUs > 0) {

                             reinterpret_cast<MPEG4Writer *>(writer.get())->

media/libstagefright/ASFExtractor.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -0,0 +1,179 @@

                    +/**

                    + *****************************************************************************

                    + *

                    + *  @file     ASFExtractor.cpp

                    + *

                    + *  @brief    This file works as a wrapper to the ASFExtractor class

                    + *

                    + *****************************************************************************

                    + */

                    +

                    +#define LOG_TAG "ASFDummyExtractor"

                    +#include <utils/Log.h>

                    +

                    +#include <media/stagefright/MediaSource.h>

                    +#include <media/stagefright/MetaData.h>

                    +#include <media/stagefright/MediaExtractor.h>

                    +#include <utils/Vector.h>

                    +#include <dlfcn.h>   /* For dynamic loading */

                    +#include "include/ASFExtractor.h"

                    +

                    +

                    +namespace android {

                    +    static void * pASFHandle = NULL;

                    +

                    +ASFExtractor::ASFExtractor(const sp<DataSource> &source) {

                    +    const char *errstr;

                    +    LOGD("Dummy ASFExtractor contructor");

                    +

                    +    pASFParser = new ASF_WRAPER;

                    +

                    +    pASFParser->ASFExtractor =     ( ASFExtractorImpl* (*)(const android::sp<android::DataSource>&))dlsym(pASFHandle, "ASFExtractor");

                    +    if((errstr = dlerror()) != NULL){

                    +        LOGE("dlsym(), err: %s", errstr);

                    +        dlclose(pASFHandle);

                    +        delete pASFParser;

                    +        return;

                    +    }

                    +    pASFParser->destructorASFExtractor =     (void (*)(ASFExtractorImpl *))dlsym(pASFHandle, "destructorASFExtractor");

                    +    if((errstr = dlerror()) != NULL){

                    +        LOGE("dlsym(), err: %s", errstr);

                    +        dlclose(pASFHandle);

                    +        delete pASFParser;

                    +        return;

                    +    }

                    +    pASFParser->countTracks =       (size_t (*)(ASFExtractorImpl *))dlsym(pASFHandle, "countTracks");

                    +    if((errstr = dlerror()) != NULL){

                    +        LOGE("dlsym(), err: %s", errstr);

                    +        dlclose(pASFHandle);

                    +        delete pASFParser;

                    +        return;

                    +    }

                    +    pASFParser->getTrack =          (android::sp<android::MediaSource> (*)(size_t, ASFExtractorImpl *))dlsym(pASFHandle, "getTrack");

                    +    if((errstr = dlerror()) != NULL){

                    +        LOGE("dlsym(), err: %s", errstr);

                    +        dlclose(pASFHandle);

                    +        delete pASFParser;

                    +        return;

                    +    }

                    +    pASFParser->getTrackMetaData =  (android::sp<android::MetaData> (*)(size_t, uint32_t, ASFExtractorImpl *))dlsym(pASFHandle, "getTrackMetaData");

                    +    if((errstr = dlerror()) != NULL){

                    +        LOGE("dlsym(), err: %s", errstr);

                    +        dlclose(pASFHandle);

                    +        delete pASFParser;

                    +        return;

                    +    }

                    +    pASFParser->getMetaData =       (android::sp<android::MetaData> (*)(ASFExtractorImpl *))dlsym(pASFHandle, "getMetaData");

                    +    if((errstr = dlerror()) != NULL){

                    +        LOGE("dlsym(), err: %s", errstr);

                    +        dlclose(pASFHandle);

                    +        delete pASFParser;

                    +        return;

                    +    }

                    +

                    +

                    +    mHandle = (*pASFParser->ASFExtractor)(source);

                    +}

                    +

                    +ASFExtractor::~ASFExtractor() {

                    +    LOGD("Dummy ASFExtractor destructor");

                    +    if(!pASFParser) {

                    +        return;

                    +    }

                    +

                    +    (pASFParser->destructorASFExtractor)(mHandle);

                    +

                    +  // Commented to handle the MediaSource::getFormat() issue.

                    +    delete pASFParser;

                    +    pASFParser = NULL;

                    +}

                    +

                    +size_t ASFExtractor::countTracks() {

                    +    LOGV("Dummy ASFExtractor::countTracks()");

                    +    if(!pASFParser) {

                    +        return 0;

                    +    }

                    +

                    +    return (*pASFParser->countTracks)(mHandle);

                    +}

                    +

                    +sp<MediaSource> ASFExtractor::getTrack(size_t index) {

                    +    LOGV("Dummy ASFExtractor::getTrack()");

                    +    if(!pASFParser) {

                    +        return NULL;

                    +    }

                    +

                    +    return (*pASFParser->getTrack)(index, mHandle);

                    +}

                    +

                    +sp<MetaData> ASFExtractor::getTrackMetaData(

                    +        size_t index, uint32_t flags) {

                    +    if(!pASFParser) {

                    +        return NULL;

                    +    }

                    +

                    +    return (*pASFParser->getTrackMetaData)(index, flags, mHandle);

                    +}

                    +

                    +sp<MetaData> ASFExtractor::getMetaData() {

                    +    LOGV("Dummy ASFExtractor::getMetaData()");

                    +    if(!pASFParser) {

                    +        return NULL;

                    +    }

                    +

                    +    return (*pASFParser->getMetaData)(mHandle);

                    +}

                    +

                    +bool SniffASF(const sp<DataSource> &source,

                    +              String8 *mimeType,

                    +              float *confidence,

                    +              sp<AMessage> *meta)

                    +{

                    +    const char *errstr;

                    +

                    +    static bool (*pSniffASF)(

                    +        const sp<DataSource> &source,

                    +        String8 *mimeType,

                    +        float *confidence,

                    +        sp<AMessage> *meta);

                    +

                    +    LOGV("Dummy SniffASF function");

                    +

                    +    if(!pASFHandle) {

                    +        pASFHandle = dlopen("/system/lib/libittiam_asfextractor.so", RTLD_LAZY | RTLD_GLOBAL);

                    +        if((errstr = dlerror()) != NULL){

                    +            LOGE("dlopen() err: %s", errstr);

                    +            return false;

                    +        }

                    +    }

                    +

                    +    pSniffASF =(bool (*)(const android::sp<android::DataSource>&, android::String8*, float*, android::sp<android::AMessage>*)) dlsym(pASFHandle, "SniffASF");

                    +    if((errstr = dlerror()) != NULL) {

                    +        LOGE("Error dlsym(pSniffASF), err: %s", errstr);

                    +        return false;

                    +    }

                    +    return (*pSniffASF)(source, mimeType, confidence, meta);

                    +}

                    +

                    +bool isASFParserAvailable()

                    +{

                    +    FILE *pF;

                    +

                    +    pF = fopen("/system/lib/libittiam_asfextractor.so", "r");

                    +    if(!pF) {

                    +        LOGW("ASF parser is not available");

                    +        return false;

                    +    }

                    +    fclose(pF);

                    +

                    +    return true;

                    +}

                    +

                    +void closeASFLib()

                    +{

                    +    if (pASFHandle) {

                    +        dlclose(pASFHandle);

                    +        pASFHandle = NULL;

                    +     }

                    +}

                    +}  // namespace android

media/libstagefright/Android.mk

show inline notes
View file @ 1a6862f

            
                    @@ -2,7 +2,9 @@ LOCAL_PATH:= $(call my-dir)

                     include $(CLEAR_VARS)

                     include frameworks/base/media/libstagefright/codecs/common/Config.mk

                    -

                    +ifeq ($(TARGET_BOARD_PLATFORM),omap4)

                    +LOCAL_CFLAGS += -DTARGET_OMAP4 -DARM_4K_PAGE_SIZE=4096

                    +endif

                     LOCAL_SRC_FILES:=                         \

                             AMRExtractor.cpp                  \

                             AMRWriter.cpp                     \

                    @@ -44,13 +46,35 @@ LOCAL_SRC_FILES:=                         \

                             avc_utils.cpp                     \

                             string.cpp

                    +ifeq ($(OMAP_ENHANCEMENT),true)

                    +LOCAL_SRC_FILES += \

                    +    ASFExtractor.cpp

                    +endif

                    +

                    +ifeq ($(TARGET_BOARD_PLATFORM),omap4)

                    +LOCAL_SRC_FILES +=               \

                    +        TIVideoConfigParser.cpp  \

                    +        TISEIMessagesParser.cpp

                    +endif

                     LOCAL_C_INCLUDES:= \

                       $(JNI_H_INCLUDE) \

                             $(TOP)/frameworks/base/include/media/stagefright/openmax \

                             $(TOP)/external/tremolo \

                             $(TOP)/external/flac/include \

                             $(TOP)/frameworks/base/media/libstagefright/rtsp

                    +ifeq ($(OMAP_ENHANCEMENT),true)

                    +LOCAL_C_INCLUDES += \

                    +        $(TOP)/hardware/ti/omap3/liboverlay

                    +endif

                    +ifeq ($(TARGET_BOARD_PLATFORM),omap4)

                    +LOCAL_C_INCLUDES +=          \

                    +  hardware/ti/omx/ducati/domx/system/omx_core/inc \

                    +  hardware/ti/omap3/camera-omap4/inc

                    +endif

                    +ifeq ($(OMAP_ENHANCEMENT),true)

                    +LOCAL_C_INCLUDES += $(TOP)/hardware/ti/omap3/liboverlay

                    +endif

                     LOCAL_SHARED_LIBRARIES := \

                             libbinder         \

                             libmedia          \

                    @@ -63,6 +87,11 @@ LOCAL_SHARED_LIBRARIES := \

                             libcamera_client  \

                             libFLAC

                    +ifeq ($(TARGET_BOARD_PLATFORM),omap4)

                    +LOCAL_SHARED_LIBRARIES += \

                    +  libcamera

                    +endif

                    +

                     LOCAL_STATIC_LIBRARIES := \

                             libstagefright_aacdec \

                             libstagefright_aacenc \

media/libstagefright/AudioPlayer.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -26,7 +26,9 @@

                     #include <media/stagefright/MediaErrors.h>

                     #include <media/stagefright/MediaSource.h>

                     #include <media/stagefright/MetaData.h>

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +#include <media/stagefright/MediaErrors.h>

                    +#endif

                     #include "include/AwesomePlayer.h"

                     namespace android {

                    @@ -68,6 +70,11 @@ status_t AudioPlayer::start(bool sourceAlreadyStarted) {

                         CHECK(!mStarted);

                         CHECK(mSource != NULL);

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    mRealTimeInterpolation = GetSystemTimeuSec();

                    +#endif

                    +

                    +

                         status_t err;

                         if (!sourceAlreadyStarted) {

                             err = mSource->start();

                    @@ -182,10 +189,24 @@ void AudioPlayer::pause(bool playPendingSamples) {

                             }

                         }

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +void AudioPlayer::flush() {

                    +    CHECK(mStarted);

                    +    if (mAudioSink.get() != NULL) {

                    +        mAudioSink->flush();

                    +    } else {

                    +        mAudioTrack->flush();

                    +    }

                    +}

                    +#endif

                     void AudioPlayer::resume() {

                         CHECK(mStarted);

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    mRealTimeInterpolation = GetSystemTimeuSec();

                    +#endif

                    +

                         if (mAudioSink.get() != NULL) {

                             mAudioSink->start();

                         } else {

                    @@ -387,12 +408,61 @@ size_t AudioPlayer::fillBuffer(void *data, size_t size) {

                         Mutex::Autolock autoLock(mLock);

                         mNumFramesPlayed += size_done / mFrameSize;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    //Reset the interpolation time

                    +    mRealTimeInterpolation = GetSystemTimeuSec();

                    +#endif

                         return size_done;

                     }

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +//Function to get the system time

                    +int64_t AudioPlayer::GetSystemTimeuSec(){

                    +    struct timeval tv;

                    +    gettimeofday(&tv, NULL);

                    +    return ((int64_t)tv.tv_sec * 1000000 + tv.tv_usec);

                    +}

                    +#endif

                    +

                     int64_t AudioPlayer::getRealTimeUs() {

                         Mutex::Autolock autoLock(mLock);

                    +

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    int64_t realtime = getRealTimeUsLocked();

                    +

                    +    //We need to interpolate the time to reolution of 1msec

                    +    //to get precise posting of buffers

                    +    int64_t deltaFromPosting = 0;

                    +

                    +    //Take care of first time read in case no frame has returned

                    +    if(mRealTimeInterpolation ==0){

                    +        LOGV("reset %lld",mRealTimeInterpolation);

                    +        mRealTimeInterpolation = GetSystemTimeuSec();

                    +        deltaFromPosting = 0;

                    +    }

                    +    else{

                    +        //Fetch the delta time from the last time we got the audio

                    +        //frame completion. We are only intereseted in delata

                    +        LOGV("mRealTimeInterpolation %lld = %lld - %lld",

                    +          ((int64_t)GetSystemTimeuSec()) - mRealTimeInterpolation,

                    +          ((int64_t)GetSystemTimeuSec()), mRealTimeInterpolation);

                    +

                    +        deltaFromPosting =  GetSystemTimeuSec() - mRealTimeInterpolation;

                    +    }

                    +

                    +    //if audio hangs we should drop frames. We will wait worst case of

                    +    //1 Sec

                    +    if((deltaFromPosting > 1000000) || (deltaFromPosting < 0) ) {

                    +        LOGE("To late ... there is a hang %lld",deltaFromPosting);

                    +        return realtime;

                    +    }

                    +

                    +    LOGV("IPT %lld",deltaFromPosting/1000);

                    +    return realtime + deltaFromPosting;

                    +#else

                         return getRealTimeUsLocked();

                    +#endif

                    +

                     }

                     int64_t AudioPlayer::getRealTimeUsLocked() const {

media/libstagefright/AwesomePlayer.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -49,10 +49,27 @@

                     #include <media/stagefright/foundation/ALooper.h>

                    -namespace android {

                    +#ifdef OMAP_ENHANCEMENT

                    +#include "include/ASFExtractor.h"

                    +

                    +#if defined(TARGET_OMAP4)

                    +#include <OMX_TI_Video.h>

                    +#include <OMX_TI_Common.h>

                    +#include <OMX_TI_IVCommon.h>

                    +#endif

                    +

                    +#endif

                    +namespace android {

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +extern void updateMetaData(sp<MetaData> meta_track);

                    +#endif

                     static int64_t kLowWaterMarkUs = 2000000ll;  // 2secs

                    +#ifndef OMAP_ENHANCEMENT

                     static int64_t kHighWaterMarkUs = 10000000ll;  // 10secs

                    +#else

                    +static int64_t kHighWaterMarkUs = 6000000ll;  // 6secs

                    +#endif

                     static const size_t kLowWaterMarkBytes = 40000;

                     static const size_t kHighWaterMarkBytes = 200000;

                    @@ -95,6 +112,28 @@ struct AwesomeRemoteRenderer : public AwesomeRenderer {

                             }

                         }

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual Vector< sp<IMemory> > getBuffers(){

                    +        return mTarget->getBuffers();

                    +    }

                    +

                    +    virtual bool setCallback(release_rendered_buffer_callback cb, void *cookie) {

                    +        return mTarget->setCallback(cb, cookie);

                    +    }

                    +

                    +    virtual void set_s3d_frame_layout(uint32_t s3d_mode, uint32_t s3d_fmt, uint32_t s3d_order, uint32_t s3d_subsampling) {

                    +         mTarget->set_s3d_frame_layout(s3d_mode, s3d_fmt, s3d_order, s3d_subsampling);

                    +    }

                    +

                    +    virtual void resizeRenderer(void* resize_params) {

                    +        mTarget->resizeRenderer(resize_params);

                    +    }

                    +

                    +    virtual void requestRendererClone(bool enable) {

                    +        mTarget->requestRendererClone(enable);

                    +    }

                    +#endif

                    +

                     private:

                         sp<IOMXRenderer> mTarget;

                    @@ -133,6 +172,18 @@ struct AwesomeLocalRenderer : public AwesomeRenderer {

                             mTarget->render(data, size, NULL);

                         }

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual Vector< sp<IMemory> > getBuffers(){

                    +        return mTarget->getBuffers();

                    +    }

                    +    virtual void resizeRenderer(void* resize_params) {

                    +        mTarget->resizeRenderer(resize_params);

                    +    }

                    +    virtual void requestRendererClone(bool enable) {

                    +        mTarget->requestRendererClone(enable);

                    +    }

                    +#endif

                    +

                     protected:

                         virtual ~AwesomeLocalRenderer() {

                             delete mTarget;

                    @@ -238,6 +289,13 @@ status_t AwesomeLocalRenderer::init(

                         return ((SoftwareRenderer *)mTarget)->initCheck();

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +static void releaseRenderedBufferCallback(const sp<IMemory>& mem, void *cookie){

                    +    AwesomePlayer *ap = static_cast<AwesomePlayer *>(cookie);

                    +    ap->releaseRenderedBuffer(mem);

                    +}

                    +#endif

                    +

                     AwesomePlayer::AwesomePlayer()

                         : mQueueStarted(false),

                           mTimeSource(NULL),

                    @@ -245,7 +303,16 @@ AwesomePlayer::AwesomePlayer()

                           mAudioPlayer(NULL),

                           mFlags(0),

                           mExtractorFlags(0),

                    +#ifdef OMAP_ENHANCEMENT

                    +      mBufferReleaseCallbackSet(false),

                    +      mIsFirstVideoBuffer(false),

                    +      mFirstVideoBufferResult(OK),

                    +      mFirstVideoBuffer(NULL),

                    +      mExtractorType(NULL),

                    +      mExtractor(NULL),

                    +#else

                           mLastVideoBuffer(NULL),

                    +#endif

                           mVideoBuffer(NULL),

                           mSuspensionState(NULL) {

                         CHECK_EQ(mClient.connect(), OK);

                    @@ -264,6 +331,16 @@ AwesomePlayer::AwesomePlayer()

                         mAudioStatusEventPending = false;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    mS3Dparams.active = S3D_MODE_OFF;

                    +    mS3Dparams.mode = S3D_MODE_OFF;

                    +    mS3Dparams.fmt = S3D_FORMAT_NONE;

                    +    mS3Dparams.order = S3D_ORDER_LF;

                    +    mS3Dparams.subsampling = S3D_SS_NONE;

                    +    mS3Dparams.metadata = S3D_SEI_NONE;

                    +    mVideoMode = VID_MODE_NORMAL;

                    +#endif

                    +

                         reset();

                     }

                    @@ -275,6 +352,9 @@ AwesomePlayer::~AwesomePlayer() {

                         reset();

                         mClient.disconnect();

                    +#ifdef OMAP_ENHANCEMENT

                    +    mExtractor.clear();

                    +#endif

                     }

                     void AwesomePlayer::cancelPlayerEvents(bool keepBufferingGoing) {

                    @@ -304,6 +384,9 @@ status_t AwesomePlayer::setDataSource(

                     status_t AwesomePlayer::setDataSource_l(

                             const char *uri, const KeyedVector<String8, String8> *headers) {

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    LOGD("setDataSource_l(%s)", uri);

                    +#endif

                         reset_l();

                         mUri = uri;

                    @@ -345,6 +428,17 @@ status_t AwesomePlayer::setDataSource_l(

                         if (extractor == NULL) {

                             return UNKNOWN_ERROR;

                         }

                    +#ifdef OMAP_ENHANCEMENT

                    +    sp<MetaData> fileMetadata = extractor->getMetaData();

                    +    bool isAvailable = fileMetadata->findCString(kKeyMIMEType, &mExtractorType);

                    +    if(isAvailable) {

                    +        LOGV("%s:: ExtractorType %s", __FUNCTION__,  mExtractorType);

                    +    }

                    +    else {

                    +        LOGV("%s:: ExtractorType not available", __FUNCTION__);

                    +    }

                    +    mExtractor = extractor;

                    +#endif

                         return setDataSource_l(extractor);

                     }

                    @@ -381,7 +475,20 @@ status_t AwesomePlayer::setDataSource_l(const sp<MediaExtractor> &extractor) {

                             CHECK(meta->findCString(kKeyMIMEType, &mime));

                             if (!haveVideo && !strncasecmp(mime, "video/", 6)) {

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +           sp<MediaSource> mysource = extractor->getTrack(i);

                    +            if(!strcasecmp(mime, MEDIA_MIMETYPE_VIDEO_WMV)){

                    +                LOGV("ASF parser doesn't support parseSEIMessages()");

                    +            }

                    +            else {

                    +                LOGV("Call parseSEIMessages()");

                    +                mysource->parseSEIMessages(mS3Dparams);

                    +            }

                    +            LOGV("Call setVideoSource(mysource)");

                    +           setVideoSource(mysource);

                    +#else

                                 setVideoSource(extractor->getTrack(i));

                    +#endif

                                 haveVideo = true;

                             } else if (!haveAudio && !strncasecmp(mime, "audio/", 6)) {

                                 setAudioSource(extractor->getTrack(i));

                    @@ -439,6 +546,10 @@ void AwesomePlayer::reset_l() {

                         mAudioTrack.clear();

                         mVideoTrack.clear();

                    +#ifdef OMAP_ENHANCEMENT

                    +    mVideoMode = VID_MODE_NORMAL;

                    +#endif

                    +

                         // Shutdown audio first, so that the respone to the reset request

                         // appears to happen instantaneously as far as the user is concerned

                         // If we did this later, audio would continue playing while we

                    @@ -457,12 +568,34 @@ void AwesomePlayer::reset_l() {

                         delete mAudioPlayer;

                         mAudioPlayer = NULL;

                    +#ifndef OMAP_ENHANCEMENT

                         mVideoRenderer.clear();

                    +#endif

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +    if (mBuffersWithRenderer.size()) {

                    +        unsigned int i;

                    +        unsigned int sz = mBuffersWithRenderer.size();

                    +

                    +        for(i = 0; i < sz; i++){

                    +            mBuffersWithRenderer[i]->release();

                    +        }

                    +        for(i = 0; i < sz; i++){

                    +            mBuffersWithRenderer.pop();

                    +        }

                    +    }

                    +    // release reference in case it exists

                    +    if (mFirstVideoBuffer != NULL) {

                    +        mFirstVideoBuffer->release();

                    +        mFirstVideoBuffer = NULL;

                    +    }

                    +#else

                         if (mLastVideoBuffer) {

                             mLastVideoBuffer->release();

                             mLastVideoBuffer = NULL;

                         }

                    +#endif

                         if (mVideoBuffer) {

                             mVideoBuffer->release();

                    @@ -492,6 +625,10 @@ void AwesomePlayer::reset_l() {

                             IPCThreadState::self()->flushCommands();

                         }

                    +#ifdef OMAP_ENHANCEMENT

                    +    mVideoRenderer.clear();

                    +#endif

                    +

                         mDurationUs = -1;

                         mFlags = 0;

                         mExtractorFlags = 0;

                    @@ -593,11 +730,18 @@ void AwesomePlayer::onBufferingUpdate() {

                                     if ((mFlags & PLAYING) && !eos

                                             && (cachedDataRemaining < kLowWaterMarkBytes)) {

                    +#ifdef OMAP_ENHANCEMENT

                    +                //if low cache duration is caused by a seek, wait audio callback to avoid MEDIA_SEEK_COMPLETE being lost.

                    +                if (!mWatchForAudioSeekComplete) {

                    +#endif

                                         LOGI("cache is running low (< %d) , pausing.",

                                              kLowWaterMarkBytes);

                                         mFlags |= CACHE_UNDERRUN;

                                         pause_l();

                                         notifyListener_l(MEDIA_INFO, MEDIA_INFO_BUFFERING_START);

                    +#ifdef OMAP_ENHANCEMENT

                    +                }

                    +#endif

                                     } else if (eos || cachedDataRemaining > kHighWaterMarkBytes) {

                                         if (mFlags & CACHE_UNDERRUN) {

                                             LOGI("cache has filled up (> %d), resuming.",

                    @@ -620,11 +764,18 @@ void AwesomePlayer::onBufferingUpdate() {

                         if (getCachedDuration_l(&cachedDurationUs, &eos)) {

                             if ((mFlags & PLAYING) && !eos

                                     && (cachedDurationUs < kLowWaterMarkUs)) {

                    +#ifdef OMAP_ENHANCEMENT

                    +            //if low cache duration is caused by a seek, wait audio callback to avoid MEDIA_SEEK_COMPLETE being lost.

                    +            if (!mWatchForAudioSeekComplete) {

                    +#endif

                                 LOGI("cache is running low (%.2f secs) , pausing.",

                                      cachedDurationUs / 1E6);

                                 mFlags |= CACHE_UNDERRUN;

                                 pause_l();

                                 notifyListener_l(MEDIA_INFO, MEDIA_INFO_BUFFERING_START);

                    +#ifdef OMAP_ENHANCEMENT

                    +            }

                    +#endif

                             } else if (eos || cachedDurationUs > kHighWaterMarkUs) {

                                 if (mFlags & CACHE_UNDERRUN) {

                                     LOGI("cache has filled up (%.2f secs), resuming.",

                    @@ -649,10 +800,12 @@ void AwesomePlayer::partial_reset_l() {

                         mVideoRenderer.clear();

                    +#ifndef OMAP_ENHANCEMENT

                         if (mLastVideoBuffer) {

                             mLastVideoBuffer->release();

                             mLastVideoBuffer = NULL;

                         }

                    +#endif

                         if (mVideoBuffer) {

                             mVideoBuffer->release();

                    @@ -759,6 +912,35 @@ status_t AwesomePlayer::play_l() {

                         mFlags |= PLAYING;

                         mFlags |= FIRST_FRAME;

                    +#ifdef OMAP_ENHANCEMENT

                    +    if(mVideoSource != NULL) {

                    +         if (mFirstVideoBuffer != NULL) {

                    +                    mFirstVideoBuffer->release();

                    +                    mFirstVideoBuffer = NULL;

                    +        }

                    +        mFirstVideoBufferResult = mVideoSource->read(&mFirstVideoBuffer);

                    +        if (mFirstVideoBufferResult == INFO_FORMAT_CHANGED) {

                    +            LOGV("First INFO_FORMAT_CHANGED!!!");

                    +            LOGV("VideoSource signalled format change.");

                    +            if (mVideoRenderer != NULL) {

                    +                mVideoRendererIsPreview = false;

                    +                initRenderer_l();

                    +#ifdef OMAP_ENHANCEMENT

                    +            if (mVideoRenderer != NULL) {

                    +                // Share overlay buffers with video decoder.

                    +                mVideoSource->setBuffers(mVideoRenderer->getBuffers(), true);

                    +            }

                    +#endif

                    +            }

                    +            CHECK(mFirstVideoBuffer == NULL);

                    +            mFirstVideoBufferResult = OK;

                    +            mIsFirstVideoBuffer = false;

                    +        } 

                    +       else {

                    +            mIsFirstVideoBuffer = true;

                    +        }

                    +}

                    +#endif

                         bool deferredAudioSeek = false;

                         if (mAudioSource != NULL) {

                    @@ -777,7 +959,12 @@ status_t AwesomePlayer::play_l() {

                                         mAudioPlayer = NULL;

                                         mFlags &= ~(PLAYING | FIRST_FRAME);

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +                    if (mFirstVideoBuffer) {

                    +                        mFirstVideoBuffer->release();

                    +                        mFirstVideoBuffer = NULL;

                    +                    }

                    +#endif

                                         return err;

                                     }

                    @@ -789,7 +976,25 @@ status_t AwesomePlayer::play_l() {

                                     mWatchForAudioEOS = true;

                                 }

                             } else {

                    +#ifdef OMAP_ENHANCEMENT

                    +            if (!mSeeking || mVideoSource == NULL) {

                    +               // Resume when video is not present or when

                    +               // not seeking and flush the sink so buffer from

                    +                //previous position is not heard

                    +                if(mSeeking){

                    +                    if(mAudioSink.get() != NULL){

                    +                        mAudioSink->flush();

                    +                    }

                    +                }

                    +                mAudioPlayer->resume();

                    +            } else {

                    +                // when seeking it is too early to resume

                    +                // as audio has not seek yet

                    +                mFlags |= HOLD_TO_RESUME;

                    +            }

                    +#else

                                 mAudioPlayer->resume();

                    +#endif

                             }

                         }

                    @@ -831,7 +1036,41 @@ status_t AwesomePlayer::initRenderer_l() {

                         CHECK(meta->findCString(kKeyDecoderComponent, &component));

                         CHECK(meta->findInt32(kKeyWidth, &decodedWidth));

                         CHECK(meta->findInt32(kKeyHeight, &decodedHeight));

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +#ifdef TARGET_OMAP4

                    +    CHECK(meta->findInt32(kKeyWidth, &mVideoWidth));

                    +    CHECK(meta->findInt32(kKeyHeight, &mVideoHeight));

                    + 

                    +    if(!(meta->findInt32(kKeyPaddedWidth, &decodedWidth))) {

                    +       CHECK(meta->findInt32(kKeyWidth, &decodedWidth));

                    +    }

                    +    if(!(meta->findInt32(kKeyPaddedHeight, &decodedHeight))) {

                    +       CHECK(meta->findInt32(kKeyHeight, &decodedHeight));

                    +    }

                    +#endif

                    +    LOGD(" initRenderer_l %dx%d",decodedWidth,decodedHeight );

                    +    LOGD(" initRenderer_l %dx%d",mVideoWidth,mVideoHeight );

                    +    if (mVideoRenderer != NULL) {

                    +        //we cant destroy overlay based renderer here,as the overlay has 2 handles 

                    +        //(1) from media server process (the current process)

                    +        //(2) from surface flinger process.

                    +        // Hence, we have to resize the renderer for new dimensions than dstroying and  

                    +        // re-creating

                    +

                    +        uint32_t outputBufferCnt = -1;

                    +        outputBufferCnt = mVideoSource->getNumofOutputBuffers();

                    +        LOGD("Codec Recommended outputBuffer count after portreconfig %d",outputBufferCnt);

                    +        render_resize_params resize_params;

                    +        resize_params.decoded_width = decodedWidth;

                    +        resize_params.decoded_height = decodedHeight;

                    +        resize_params.buffercount = outputBufferCnt;

                    +        resize_params.display_width = mVideoWidth;

                    +        resize_params.display_height = mVideoHeight;

                    +

                    +        mVideoRenderer->resizeRenderer((void*)(&resize_params));

                    +        return 0;

                    +    } 

                    +#endif

                         int32_t rotationDegrees;

                         if (!mVideoTrack->getFormat()->findInt32(

                                     kKeyRotation, &rotationDegrees)) {

                    @@ -840,6 +1079,11 @@ status_t AwesomePlayer::initRenderer_l() {

                         mVideoRenderer.clear();

                    +#if defined( OMAP_ENHANCEMENT) && !defined(TARGET_OMAP4)

                    +    // Initializing S3D flag, to be passed by higher layer

                    +    int isS3D =0;

                    +#endif

                    +

                         // Must ensure that mVideoRenderer's destructor is actually executed

                         // before creating a new one.

                         IPCThreadState::self()->flushCommands();

                    @@ -849,6 +1093,44 @@ status_t AwesomePlayer::initRenderer_l() {

                             // therefore they require a remote IOMXRenderer that knows how

                             // to display them.

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +        //initialize the codec recommended buffers to -1

                    +        int32_t outputBufferCnt = -1;

                    +        outputBufferCnt = mVideoSource->getNumofOutputBuffers();

                    +        LOGD("Codec Recommended outputBuffer count %d",outputBufferCnt);

                    +

                    +        sp<IOMXRenderer> native =

                    +            mClient.interface()->createRenderer(

                    +                    mISurface, component,

                    +                    (OMX_COLOR_FORMATTYPE)format,

                    +                    decodedWidth, decodedHeight,

                    +                    mVideoWidth, mVideoHeight,

                    +                    rotationDegrees, mS3Dparams.active, outputBufferCnt);

                    +

                    +        if (native == NULL) {

                    +            return NO_INIT;

                    +        }

                    +

                    +        mVideoRenderer = new AwesomeRemoteRenderer(native);

                    +

                    +#elif defined(OMAP_ENHANCEMENT)

                    +        int32_t outputBufferCnt = -1;

                    +

                    +        sp<IOMXRenderer> native =

                    +            mClient.interface()->createRenderer(

                    +                    mISurface, component,

                    +                    (OMX_COLOR_FORMATTYPE)format,

                    +                    decodedWidth, decodedHeight,

                    +                    mVideoWidth, mVideoHeight,

                    +                    rotationDegrees, isS3D, outputBufferCnt);

                    +

                    +        if (native == NULL) {

                    +            return NO_INIT;

                    +        }

                    +

                    +        mVideoRenderer = new AwesomeRemoteRenderer(native);

                    +

                    +#else

                             sp<IOMXRenderer> native =

                                 mClient.interface()->createRenderer(

                                         mISurface, component,

                    @@ -862,6 +1144,18 @@ status_t AwesomePlayer::initRenderer_l() {

                             }

                             mVideoRenderer = new AwesomeRemoteRenderer(native);

                    +#endif

                    +#ifdef OMAP_ENHANCEMENT

                    +            if (!strncmp("OMX.TI", component, 6)) {

                    +#if defined(TARGET_OMAP4)

                    +                if(mS3Dparams.active)

                    +                    mVideoRenderer->set_s3d_frame_layout(mS3Dparams.mode ,mS3Dparams.fmt ,mS3Dparams.order, mS3Dparams.subsampling);

                    +#endif

                    +                mBufferReleaseCallbackSet = mVideoRenderer->setCallback(releaseRenderedBufferCallback, this);

                    +                mVideoRenderer->setCallback(releaseRenderedBufferCallback, this);  

                    +            }

                    +#endif

                    +

                         } else {

                             // Other decoders are instantiated locally and as a consequence

                             // allocate their buffers in local address space.

                    @@ -890,6 +1184,12 @@ status_t AwesomePlayer::pause_l(bool at_eos) {

                             return OK;

                         }

                    +#if defined (TARGET_OMAP4) && defined (OMAP_ENHANCEMENT)

                    +    if (mVideoSource != NULL) {

                    +        // Indicating to codec that Pause button pressed

                    +        mVideoSource->pause();

                    +    }

                    +#endif

                         cancelPlayerEvents(true /* keepBufferingGoing */);

                         if (mAudioPlayer != NULL) {

                    @@ -1053,11 +1353,86 @@ status_t AwesomePlayer::initAudioDecoder() {

                         if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_RAW)) {

                             mAudioSource = mAudioTrack;

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +    }

                    +    else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_WMA)) {

                    +        const char *componentName  = "OMX.ITTIAM.WMA.decode";

                    +        mAudioSource = OMXCodec::Create(

                    +        mClient.interface(), mAudioTrack->getFormat(),

                    +        false,

                    +        mAudioTrack, componentName);

                    +        if (mAudioSource == NULL) {

                    +            LOGE("Failed to create OMX component for WMA codec");

                    +        }

                    +#endif

                         } else {

                    +#ifdef OMAP_ENHANCEMENT

                    +        if (mVideoWidth*mVideoHeight > MAX_RESOLUTION) {

                    +         // video is launched first, so these capablities are known

                    +         // audio can be selected accordingly

                    +         // TODO: extend this to a method that can include more

                    +         // capabilities to evaluate

                    +

                    +#ifdef TARGET_OMAP4

                    +            //for OMAP4 720p,1080p videos, lets stick to OMX.PV audio codecs

                    +            mAudioSource = OMXCodec::Create(

                    +                    mClient.interface(), mAudioTrack->getFormat(),

                    +                    false, // createEncoder

                    +                    mAudioTrack);

                    +#else

                    +        bool isIttiamAudioCodecRequired = false;

                    +        bool is720PCodecRequired = (mVideoWidth*mVideoHeight > MAX_RESOLUTION) ? true : false;

                    +

                    +        if (true == is720PCodecRequired) {

                    +            isIttiamAudioCodecRequired = true;

                    +        }

                    +        if (true == isIttiamAudioCodecRequired){

                    +

                    +         // video is launched first, so these capablities are known

                    +         // audio can be selected accordingly

                    +         // TODO: extend this to a method that can include more

                    +         // capabilities to evaluate

                    +

                    +            const char *componentName;

                    +            if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_AAC)) {

                    +                componentName = "OMX.ITTIAM.AAC.decode";

                    +

                    +            mAudioSource = OMXCodec::Create(

                    +                    mClient.interface(), mAudioTrack->getFormat(),

                    +                    false, // createEncoder

                    +                        mAudioTrack, componentName);

                    +            }

                    +            else if (!strcasecmp(mime, MEDIA_MIMETYPE_AUDIO_WMA)) {

                    +                componentName = "OMX.ITTIAM.WMA.decode";

                    +

                    +                mAudioSource = OMXCodec::Create(

                    +                        mClient.interface(), mAudioTrack->getFormat(),

                    +                        false,

                    +                        mAudioTrack, componentName);

                    +

                    +            }

                    +            else {

                    +                componentName = "NoComponentAvailable";

                    +

                    +                mAudioSource = OMXCodec::Create(

                    +                        mClient.interface(), mAudioTrack->getFormat(),

                    +                        false,

                    +                        mAudioTrack);

                    +            }

                    +        }

                    +#endif

                    +        } else {

                    +            mAudioSource = OMXCodec::Create(

                    +                    mClient.interface(), mAudioTrack->getFormat(),

                    +                    false, // createEncoder

                    +                    mAudioTrack);

                    +        }

                    +#else

                             mAudioSource = OMXCodec::Create(

                                     mClient.interface(), mAudioTrack->getFormat(),

                                     false, // createEncoder

                                     mAudioTrack);

                    +#endif

                         }

                         if (mAudioSource != NULL) {

                    @@ -1091,12 +1466,136 @@ void AwesomePlayer::setVideoSource(sp<MediaSource> source) {

                         mVideoTrack = source;

                     }

                    +#if defined(TARGET_OMAP4) && defined(OMAP_ENHANCEMENT)

                    +/*

                    +  * Dynamically update S3D display driver based on framelayout configuration changes

                    +  * sent by Codec as OMX metadata

                    +  */

                    +void AwesomePlayer::updateS3DRenderer()

                    +{

                    +

                    +    status_t ret = NO_ERROR;

                    +    void *OMXplaformPrivate;

                    +    OMX_OTHER_EXTRADATATYPE *extraData;

                    +    int32_t lCounter = 0;

                    +

                    +    CHECK_EQ(mVideoBuffer->meta_data()->findPointer(kKeyPlatformPrivate, &OMXplaformPrivate), true);

                    +

                    +    if ( ((OMX_TI_PLATFORMPRIVATE *)OMXplaformPrivate)->nMetaDataSize <= 0 || ((OMX_TI_PLATFORMPRIVATE *) OMXplaformPrivate)->pMetaDataBuffer == NULL)

                    +    {

                    +        LOGV("No MetaData in this buffer \n");

                    +        return;

                    +    }

                    +

                    +    do

                    +    {

                    +        extraData = (OMX_OTHER_EXTRADATATYPE *) (((OMX_TI_PLATFORMPRIVATE *) OMXplaformPrivate)->pMetaDataBuffer + lCounter);

                    +        switch( extraData-> eType)

                    +        {

                    +            case OMX_TI_SEIinfo2004Frame1:

                    +            case OMX_TI_SEIinfo2004Frame2:

                    +            {

                    +                if(configSEI2004Infos(extraData))

                    +                    //update S3D driver dynamic configuration parameters

                    +                    mVideoRenderer->set_s3d_frame_layout(mS3Dparams.mode ,mS3Dparams.fmt ,mS3Dparams.order, mS3Dparams.subsampling);

                    +                return;

                    +                break;

                    +            }

                    +            case OMX_TI_SEIinfo2010Frame1:

                    +            case OMX_TI_SEIinfo2010Frame2:

                    +            {

                    +                if(configSEI2010Infos(extraData))

                    +                    //update S3D driver dynamic configuration parameters

                    +                    mVideoRenderer->set_s3d_frame_layout(mS3Dparams.mode ,mS3Dparams.fmt ,mS3Dparams.order, mS3Dparams.subsampling);

                    +                return;

                    +                break;

                    +            }

                    +            default:

                    +            {

                    +                LOGV("No SEI meta data \n");

                    +                break;

                    +            }

                    +        }

                    +        lCounter += extraData->nSize;

                    +    }while ((lCounter < ( (OMX_TI_PLATFORMPRIVATE *)OMXplaformPrivate)->nMetaDataSize ) && (extraData-> eType !=0 ));

                    +

                    +}

                    +

                    +bool AwesomePlayer::configSEI2004Infos(OMX_OTHER_EXTRADATATYPE *extraData)

                    +{

                    +    if(mS3Dparams.metadata != S3D_SEI_STEREO_INFO_PROGRESSIVE || mS3Dparams.metadata != S3D_SEI_STEREO_INFO_INTERLACED)

                    +        LOGV("SEI buffer configuration changed \n");

                    +

                    +    OMX_TI_STEREODECINFO * pstereoDecInfo;

                    +    pstereoDecInfo = (OMX_TI_STEREODECINFO *) (extraData->data);

                    +

                    +    if(sizeof(OMX_TI_STEREODECINFO) == extraData->nDataSize)

                    +    {

                    +        if(pstereoDecInfo->nFieldViewsFlag)

                    +        {

                    +            if(pstereoDecInfo->nTopFieldIsLeftViewFlag)

                    +                mS3Dparams.order = S3D_ORDER_LF;

                    +            else

                    +                mS3Dparams.order = S3D_ORDER_RF;

                    +        }

                    +        else

                    +        {

                    +             if(pstereoDecInfo->nCurrentFrameIsLeftViewFlag)

                    +                mS3Dparams.order = S3D_ORDER_LF;

                    +            else

                    +                mS3Dparams.order = S3D_ORDER_RF;

                    +        }

                    +        return true;

                    +    }

                    +    return false;

                    +}

                    +

                    +bool AwesomePlayer::configSEI2010Infos(OMX_OTHER_EXTRADATATYPE *extraData)

                    +{

                    +    if(mS3Dparams.metadata != S3D_SEI_STEREO_FRAME_PACKING)

                    +        LOGV("SEI buffer configuration changed \n");

                    +

                    +    OMX_TI_FRAMEPACKINGDECINFO * pframePackingDecInfo;

                    +    pframePackingDecInfo = (OMX_TI_FRAMEPACKINGDECINFO *) (extraData->data);

                    +

                    +    if(sizeof(OMX_TI_FRAMEPACKINGDECINFO) == extraData->nDataSize)

                    +    {

                    +        if(pframePackingDecInfo->nFramePackingArrangementCancelFlag)

                    +        {

                    +            set_frame_packing_arrangement_type(pframePackingDecInfo->nFramePackingArrangementType, mS3Dparams.fmt, mS3Dparams.subsampling);

                    +            if(pframePackingDecInfo->nContentInterpretationType)

                    +                mS3Dparams.order = S3D_ORDER_LF;

                    +            else

                    +                mS3Dparams.order = S3D_ORDER_RF;

                    +            return true;

                    +        }

                    +    }

                    +    return false;

                    +}

                    +#endif

                    +

                     status_t AwesomePlayer::initVideoDecoder(uint32_t flags) {

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +

                    +    //Call config parser to update profile,level,interlaced,reference frame data

                    +    updateMetaData(mVideoTrack->getFormat());

                    +

                    +    int32_t isInterlaced = false;

                    +    mVideoTrack->getFormat()->findInt32(kKeyVideoInterlaced, &isInterlaced);

                    +

                    +    mVideoSource = OMXCodec::Create(

                    +            mClient.interface(), mVideoTrack->getFormat(),

                    +            false, // createEncoder

                    +            mVideoTrack,

                    +            NULL,

                    +            (flags | isInterlaced)?OMXCodec::kPreferInterlacedOutputContent:0);

                    +#else

                         mVideoSource = OMXCodec::Create(

                                 mClient.interface(), mVideoTrack->getFormat(),

                                 false, // createEncoder

                                 mVideoTrack,

                                 NULL, flags);

                    +#endif

                         if (mVideoSource != NULL) {

                             int64_t durationUs;

                    @@ -1110,12 +1609,15 @@ status_t AwesomePlayer::initVideoDecoder(uint32_t flags) {

                             CHECK(mVideoTrack->getFormat()->findInt32(kKeyWidth, &mVideoWidth));

                             CHECK(mVideoTrack->getFormat()->findInt32(kKeyHeight, &mVideoHeight));

                    +#ifndef OMAP_ENHANCEMENT

                             status_t err = mVideoSource->start();

                             if (err != OK) {

                                 mVideoSource.clear();

                                 return err;

                             }

                    +#endif

                    +

                         }

                         return mVideoSource != NULL ? OK : UNKNOWN_ERROR;

                    @@ -1157,11 +1659,17 @@ void AwesomePlayer::onVideoEvent() {

                         mVideoEventPending = false;

                         if (mSeeking) {

                    +#ifdef OMAP_ENHANCEMENT

                    +        if (mFirstVideoBuffer) {

                    +            mFirstVideoBuffer->release();

                    +            mFirstVideoBuffer = NULL;

                    +        }

                    +#else

                             if (mLastVideoBuffer) {

                                 mLastVideoBuffer->release();

                                 mLastVideoBuffer = NULL;

                             }

                    -

                    +#endif

                             if (mVideoBuffer) {

                                 mVideoBuffer->release();

                                 mVideoBuffer = NULL;

                    @@ -1187,12 +1695,33 @@ void AwesomePlayer::onVideoEvent() {

                             MediaSource::ReadOptions options;

                             if (mSeeking) {

                                 LOGV("seeking to %lld us (%.2f secs)", mSeekTimeUs, mSeekTimeUs / 1E6);

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +            if (mIsFirstVideoBuffer) {

                    +                if (mFirstVideoBuffer != NULL) {

                    +                    mFirstVideoBuffer->release();

                    +                    mFirstVideoBuffer = NULL;

                    +                }

                    +                mIsFirstVideoBuffer = false;

                    +            }

                    +#endif

                                 options.setSeekTo(

                                         mSeekTimeUs, MediaSource::ReadOptions::SEEK_CLOSEST_SYNC);

                             }

                             for (;;) {

                    +#ifdef OMAP_ENHANCEMENT

                    +            status_t err;

                    +            if (mIsFirstVideoBuffer) {

                    +                mVideoBuffer = mFirstVideoBuffer;

                    +                mFirstVideoBuffer = NULL;

                    +                err = mFirstVideoBufferResult;

                    +

                    +                mIsFirstVideoBuffer = false;

                    +            } else {

                    +                err = mVideoSource->read(&mVideoBuffer, &options);

                    +            }

                    +#else

                                 status_t err = mVideoSource->read(&mVideoBuffer, &options);

                    +#endif

                                 options.clearSeekTo();

                                 if (err != OK) {

                    @@ -1203,10 +1732,40 @@ void AwesomePlayer::onVideoEvent() {

                                         if (mVideoRenderer != NULL) {

                                             mVideoRendererIsPreview = false;

                    -                        err = initRenderer_l();

                    +#ifdef OMAP_ENHANCEMENT

                    +                        if (mBuffersWithRenderer.size()) {

                    +                            unsigned int i;

                    +                            unsigned int sz = mBuffersWithRenderer.size();

                    +

                    +                            for(i = 0; i < sz; i++){

                    +                                mBuffersWithRenderer[i]->release();

                    +                            }

                    +

                    +                            for(i = 0; i < sz; i++){

                    +                                mBuffersWithRenderer.pop();

                    +                            }

                    +                        }

                    +                        if (mFirstVideoBuffer != NULL) {

                    +                            mFirstVideoBuffer->release();

                    +                            mFirstVideoBuffer = NULL;

                    +                        }

                    +                        if (mVideoBuffer) {

                    +                            mVideoBuffer->release();

                    +                            mVideoBuffer = NULL;

                    +                        }

                    +#endif

                    +

                    +                        err = initRenderer_l();

                                             if (err == OK) {

                    -                            continue;

                    +#ifdef OMAP_ENHANCEMENT

                    +                        if (mVideoRenderer != NULL) {

                    +                            // Share overlay buffers with video decoder.

                    +                            mVideoSource->setBuffers(mVideoRenderer->getBuffers(), true);

                    +                        }

                    +                        postVideoEvent_l(0);

                    +#endif

                    +                            return;

                                             }

                                             // fall through

                    @@ -1280,22 +1839,50 @@ void AwesomePlayer::onVideoEvent() {

                             // and we'll play incoming video as fast as we get it.

                             latenessUs = 0;

                         }

                    +#ifdef OMAP_ENHANCEMENT

                    +    LOGV("%s::%d: (latenessUs= %lld) = ((nowUs= %lld) - (timeUs=%lld))", __FUNCTION__, __LINE__, latenessUs, nowUs, timeUs);

                    +    if (latenessUs > 50000) {

                    +        // We're more than 50ms late.

                    +

                    +        /* Trace to detect frame drops */

                    +        LOGV("Frame dropped - lateness (%lld - %lld = %lld uS)",nowUs,timeUs,latenessUs);

                    +

                    +#else

                         if (latenessUs > 40000) {

                             // We're more than 40ms late.

                    +#endif

                             LOGV("we're late by %lld us (%.2f secs)", latenessUs, latenessUs / 1E6);

                             mVideoBuffer->release();

                             mVideoBuffer = NULL;

                    -

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +        postVideoEvent_l(0);

                    +#else

                             postVideoEvent_l();

                    +#endif

                             return;

                         }

                    -

                    +#if defined(OMAP_ENHANCEMENT) && !defined(TARGET_OMAP4)

                    +    if (latenessUs < -100000) {

                    +        // We're more than 100ms early.

                    +        LOGV("%s::%d: Frame is early than 100ms: %lld", __FUNCTION__, __LINE__, latenessUs);

                    +        LOGV("%s::%d: postVideoEvent_l(10000)", __FUNCTION__, __LINE__);

                    +#else

                         if (latenessUs < -10000) {

                             // We're more than 10ms early.

                    +#endif

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +        //There is no need to poll for 10 msec

                    +        //This going to increase the MHz on ARM. Try to come back

                    +        //when we need to exactly post. Need to do a mod for 100 msec

                    +        //so that while seeking the video frame doesnt wait for lateness

                    +        //which can be a huge delay. This will result like a hang

                    +        postVideoEvent_l((latenessUs * -1) % 100000);

                    +#else

                             postVideoEvent_l(10000);

                    +#endif

                             return;

                         }

                    @@ -1310,21 +1897,56 @@ void AwesomePlayer::onVideoEvent() {

                                 mFlags |= VIDEO_AT_EOS;

                                 postStreamDoneEvent_l(err);

                                 return;

                    +        } else {

                    +#ifdef OMAP_ENHANCEMENT

                    +        if (mVideoRenderer != NULL) {

                    +            // Share overlay buffers with video decoder.

                    +            mVideoSource->setBuffers(mVideoRenderer->getBuffers(), true);

                             }

                    +#endif

                    +    }

                         }

                    +#ifdef OMAP_ENHANCEMENT

                    +    /*the buffer needs to be pushed to local database before calling render.

                    +    * This is required to release the buffer back to Video source if the

                    +    * buffer can't be queued to the DSS

                    +    */

                    +    mBuffersWithRenderer.push(mVideoBuffer);

                    +#endif

                    +

                         if (mVideoRenderer != NULL) {

                    +#if defined(TARGET_OMAP4) && defined(OMAP_ENHANCEMENT)

                    +    int32_t isExtraData = 0;

                    +    if(mS3Dparams.active && mVideoBuffer->meta_data()->findInt32(kKeyIsExtraData, &isExtraData))

                    +            updateS3DRenderer();

                    +#endif

                             mVideoRenderer->render(mVideoBuffer);

                         }

                    +#ifdef OMAP_ENHANCEMENT

                    +    if ((!mBufferReleaseCallbackSet)  && (mBuffersWithRenderer.size())){

                    +        mBuffersWithRenderer[0]->release();

                    +        mBuffersWithRenderer.pop();

                    +    }

                    +#else

                         if (mLastVideoBuffer) {

                             mLastVideoBuffer->release();

                             mLastVideoBuffer = NULL;

                         }

                         mLastVideoBuffer = mVideoBuffer;

                    -    mVideoBuffer = NULL;

                    +#endif

                    +    mVideoBuffer = NULL;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    // No need to trigger the poll after 10 msec which is default value

                    +    // This is causing a jerk in AV sync. We can trigger a 0 msec and accurate

                    +    // wait which will allow more ARM sleep time

                    +    postVideoEvent_l(0);

                    +#else

                         postVideoEvent_l();

                    +#endif

                    +

                     }

                     void AwesomePlayer::postVideoEvent_l(int64_t delayUs) {

                    @@ -1664,6 +2286,17 @@ status_t AwesomePlayer::finishSetDataSource_l() {

                         if (extractor == NULL) {

                             return UNKNOWN_ERROR;

                         }

                    +#ifdef OMAP_ENHANCEMENT

                    +    sp<MetaData> fileMetadata = extractor->getMetaData();

                    +    bool isAvailable = fileMetadata->findCString(kKeyMIMEType, &mExtractorType);

                    +    if(isAvailable) {

                    +        LOGV("%s:: ExtractorType %s", __FUNCTION__,  mExtractorType);

                    +    }

                    +    else {

                    +        LOGV("%s:: ExtractorType not available", __FUNCTION__);

                    +    }

                    +    mExtractor = extractor;

                    +#endif

                         return setDataSource_l(extractor);

                     }

                    @@ -1708,7 +2341,24 @@ void AwesomePlayer::onPrepareAsyncEvent() {

                         if (mVideoTrack != NULL && mVideoSource == NULL) {

                             status_t err = initVideoDecoder();

                    +#ifdef OMAP_ENHANCEMENT

                    +            if (err == OK){

                    +                if (mVideoRendererIsPreview || mVideoRenderer == NULL) {

                    +                    mVideoRendererIsPreview = false;

                    +                    initRenderer_l();

                    +                    if (mVideoRenderer != NULL) {

                    +                        // Share overlay buffers with video decoder.

                    +                        mVideoSource->setBuffers(mVideoRenderer->getBuffers(), false);

                    +                    }

                    +                }

                    +                err = mVideoSource->start();

                    +                if (err != OK) {

                    +                    mVideoSource.clear();

                    +                    //Subsequent error handling will take of returning.

                    +                }

                    +            }

                    +#endif

                             if (err != OK) {

                                 abortPrepare(err);

                                 return;

                    @@ -1769,7 +2419,11 @@ status_t AwesomePlayer::suspend() {

                         Mutex::Autolock autoLock(mLock);

                         if (mSuspensionState != NULL) {

                    +#ifdef OMAP_ENHANCEMENT

                    +        if (mBuffersWithRenderer.size() == 0) {

                    +#else

                             if (mLastVideoBuffer == NULL) {

                    +#endif

                                 //go into here if video is suspended again

                                 //after resuming without being played between

                                 //them

                    @@ -1804,20 +2458,50 @@ status_t AwesomePlayer::suspend() {

                         state->mFlags = mFlags & (PLAYING | AUTO_LOOPING | LOOPING | AT_EOS);

                         getPosition(&state->mPositionUs);

                    +#ifdef OMAP_ENHANCEMENT

                    +#ifdef TARGET_OMAP4

                    +    // FIXME: This caching of last frame crashes in L27x. Not used anyway, but check why.

                    +    // This should be removed after fill the code for (mBufferWithRenderer.size() > 0)

                    +    if (0) {

                    +#else /* TARGET_OMAP3 */

                    +    // Currently this code is used only by OMAP3.

                    +    if (mBuffersWithRenderer.size()) {

                    +#endif

                    +        size_t size = mBuffersWithRenderer[0]->range_length();

                    +#else

                         if (mLastVideoBuffer) {

                             size_t size = mLastVideoBuffer->range_length();

                    -

                    +#endif

                             if (size) {

                                 int32_t unreadable;

                    +#ifdef OMAP_ENHANCEMENT

                    +            if (!mBuffersWithRenderer[0]->meta_data()->findInt32(

                    +                        kKeyIsUnreadable, &unreadable)

                    +                    || unreadable == 0) {

                    +                state->mLastVideoFrameSize = size;

                    +                state->mLastVideoFrame = malloc(size);

                    +

                    +#ifdef TARGET_OMAP4

                    +                // FIXME: here for OMAP4

                    +                // Please fill this part for OMAP4

                    +#else

                    +                memcpy(state->mLastVideoFrame,

                    +                   (const uint8_t *)mBuffersWithRenderer[0]->data()

                    +                        + mBuffersWithRenderer[0]->range_offset(),

                    +                   size);

                    +#endif

                    +#else

                                 if (!mLastVideoBuffer->meta_data()->findInt32(

                                             kKeyIsUnreadable, &unreadable)

                                         || unreadable == 0) {

                                     state->mLastVideoFrameSize = size;

                                     state->mLastVideoFrame = malloc(size);

                    +

                                     memcpy(state->mLastVideoFrame,

                    -                       (const uint8_t *)mLastVideoBuffer->data()

                    -                            + mLastVideoBuffer->range_offset(),

                    -                       size);

                    +                   (const uint8_t *)mLastVideoBuffer->data()

                    +                        + mLastVideoBuffer->range_offset(),

                    +                   size);

                    +#endif

                                     state->mVideoWidth = mVideoWidth;

                                     state->mVideoHeight = mVideoHeight;

                    @@ -1890,6 +2574,10 @@ status_t AwesomePlayer::resume() {

                             ((AwesomeLocalRenderer *)mVideoRenderer.get())->render(

                                     state->mLastVideoFrame, state->mLastVideoFrameSize);

                    +#ifdef OMAP_ENHANCEMENT

                    +        mVideoRenderer.clear();

                    +        mVideoRenderer = NULL;

                    +#endif

                         }

                         if (state->mFlags & PLAYING) {

                    @@ -1913,6 +2601,46 @@ void AwesomePlayer::postAudioEOS() {

                     void AwesomePlayer::postAudioSeekComplete() {

                         postCheckAudioStatusEvent_l();

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +void AwesomePlayer::releaseRenderedBuffer(const sp<IMemory>& mem){

                    +

                    +    bool buffer_released = false;

                    +    unsigned int i = 0;

                    +

                    +    for(i = 0; i < mBuffersWithRenderer.size(); i++){

                    +        if (mBuffersWithRenderer[i]->data() == mem->pointer()){

                    +            mBuffersWithRenderer[i]->release();

                    +            mBuffersWithRenderer.removeAt(i);

                    +            buffer_released = true;

                    +            break;

                    +        }

                    +    }

                    +

                    +    if (buffer_released == false)

                    +        LOGD("Something wrong... Overlay returned wrong buffer address(%p). This message is harmless if you just did a seek.", mem->pointer());

                    +}

                    +

                    +

                    +status_t AwesomePlayer::requestVideoCloneMode(bool enable) {

                    +    if (enable)

                    +    {

                    +        if ((mVideoMode != VID_MODE_CLONE) && (mVideoRenderer != NULL)) {

                    +            mVideoMode = VID_MODE_CLONE;

                    +            mVideoRenderer->requestRendererClone(enable);

                    +        }

                    +    }

                    +    else

                    +    {

                    +        if ((mVideoMode != VID_MODE_NORMAL) && (mVideoRenderer != NULL)) {

                    +            mVideoMode = VID_MODE_NORMAL;

                    +            mVideoRenderer->requestRendererClone(enable);

                    +        }

                    +    }

                    +    LOGD("CloneMode[%d]", mVideoMode);

                    +    return OK;

                    +}

                    +

                    +#endif

                     }  // namespace android

media/libstagefright/CameraSource.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -30,6 +30,11 @@

                     #include <utils/String8.h>

                     #include <cutils/properties.h>

                    +#if defined(OMAP_ENHANCEMENT) && (TARGET_OMAP4)

                    +#include <TICameraParameters.h>

                    +#include "OMX_TI_Video.h"

                    +#endif

                    +

                     namespace android {

                     struct CameraSourceListener : public CameraListener {

                    @@ -37,9 +42,14 @@ struct CameraSourceListener : public CameraListener {

                         virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2);

                         virtual void postData(int32_t msgType, const sp<IMemory> &dataPtr);

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual void postDataTimestamp(

                    +            nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr,

                    +            uint32_t offset=0, uint32_t stride=0);

                    +#else

                         virtual void postDataTimestamp(

                                 nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr);

                    +#endif

                     protected:

                         virtual ~CameraSourceListener();

                    @@ -67,12 +77,23 @@ void CameraSourceListener::postData(int32_t msgType, const sp<IMemory> &dataPtr)

                              msgType, dataPtr->pointer(), dataPtr->size());

                     }

                    +#ifdef OMAP_ENHANCEMENT

                     void CameraSourceListener::postDataTimestamp(

                    -        nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr) {

                    +        nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr,

                    +        uint32_t offset, uint32_t stride)

                    +#else

                    +void CameraSourceListener::postDataTimestamp(

                    +        nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr)

                    +#endif

                    +{

                         sp<CameraSource> source = mSource.promote();

                         if (source.get() != NULL) {

                    +#ifdef OMAP_ENHANCEMENT

                    +        source->dataCallbackTimestamp(timestamp/1000, msgType, dataPtr, offset, stride);

                    +#else

                             source->dataCallbackTimestamp(timestamp/1000, msgType, dataPtr);

                    +#endif

                         }

                     }

                    @@ -82,11 +103,19 @@ static int32_t getColorFormat(const char* colorFormat) {

                         }

                         if (!strcmp(colorFormat, CameraParameters::PIXEL_FORMAT_YUV420SP)) {

                    +#if defined(TARGET_OMAP4) && defined (OMAP_ENHANCEMENT)

                    +        return OMX_COLOR_FormatYUV420PackedSemiPlanar;

                    +#else

                             return OMX_COLOR_FormatYUV420SemiPlanar;

                    +#endif

                         }

                         if (!strcmp(colorFormat, CameraParameters::PIXEL_FORMAT_YUV422I)) {

                    +#if defined(TARGET_OMAP3) && defined(OMAP_ENHANCEMENT)

                    +        return OMX_COLOR_FormatCbYCrY;

                    +#else

                             return OMX_COLOR_FormatYCbYCr;

                    +#endif

                         }

                         if (!strcmp(colorFormat, CameraParameters::PIXEL_FORMAT_RGB565)) {

                    @@ -99,6 +128,27 @@ static int32_t getColorFormat(const char* colorFormat) {

                         CHECK_EQ(0, "Unknown color format");

                     }

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +static int32_t getSEIEncodingType(const char* seiEncodingType)

                    +{

                    +    if (!strcmp(seiEncodingType, TICameraParameters::SEI_ENCODING_2004)) {

                    +       return OMX_TI_Video_AVC_2004_StereoInfoType;

                    +    }

                    +

                    +    if (!strcmp(seiEncodingType, TICameraParameters::SEI_ENCODING_2010)) {

                    +        return OMX_TI_Video_AVC_2010_StereoFramePackingType;

                    +    }

                    +

                    +    if (!strcmp(seiEncodingType, TICameraParameters::SEI_ENCODING_NONE)) {

                    +        return OMX_TI_Video_Progressive;

                    +    }

                    +

                    +    LOGE("Unsupported SEI encoding type (%s), reverting back to progressive", seiEncodingType);

                    +

                    +    return OMX_TI_Video_Progressive;

                    +}

                    +#endif

                    +

                     // static

                     CameraSource *CameraSource::Create() {

                         sp<Camera> camera = Camera::connect(0);

                    @@ -174,6 +224,54 @@ CameraSource::CameraSource(const sp<Camera> &camera)

                         mMeta->setInt32(kKeyStride, stride);

                         mMeta->setInt32(kKeySliceHeight, sliceHeight);

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +    int32_t paddedFrameWidth, paddedFrameHeight;

                    +    if (mCamera != 0) {

                    +        // Since we may not honor the preview size that app has requested

                    +        // It is a good idea to get the actual preview size and use it for video recording.

                    +        paddedFrameWidth = atoi(params.get("padded-width"));

                    +        paddedFrameHeight = atoi(params.get("padded-height"));

                    +        if (paddedFrameWidth < 0 || paddedFrameHeight < 0) {

                    +            LOGE("Failed to get camera(%p) preview size", mCamera.get());

                    +        }

                    +        LOGV("CameraSource() : padded WxH=%dx%d", paddedFrameWidth, paddedFrameHeight);

                    +    }

                    +    else

                    +    {

                    +        LOGE("mCamera is NULL");

                    +        paddedFrameWidth = width;

                    +        paddedFrameHeight = height;

                    +    }

                    +

                    +    mMeta->setInt32(kKeyPaddedWidth, paddedFrameWidth);

                    +    mMeta->setInt32(kKeyPaddedHeight, paddedFrameHeight);

                    +

                    +    int32_t  mS3DCamera = false;

                    +    if (mCamera != 0) {

                    +

                    +        if(params.get("s3d-supported")!= NULL && CameraParameters::TRUE != NULL)

                    +            mS3DCamera = strcmp(params.get("s3d-supported"), CameraParameters::TRUE) == 0;

                    +

                    +        if(mS3DCamera)

                    +        {

                    +            const char *seiEncodingTypeStr = params.get(TICameraParameters::KEY_SEI_ENCODING_TYPE);

                    +            CHECK(seiEncodingTypeStr != NULL);

                    +            int32_t seiEncodingType = getSEIEncodingType(seiEncodingTypeStr);

                    +            mMeta->setInt32(kKeySEIEncodingType, seiEncodingType);

                    +

                    +            const char *frameLayoutStr = params.get(TICameraParameters::KEY_S3D_FRAME_LAYOUT);

                    +            CHECK(frameLayoutStr != NULL);

                    +            mMeta->setCString(kKeyFrameLayout, frameLayoutStr);

                    +        }

                    +

                    +    }

                    +    else

                    +    {

                    +        LOGE("mCamera is NULL");

                    +        mS3DCamera = false;

                    +    }

                    +    mMeta->setInt32(kKeyS3dSupported, mS3DCamera);

                    +#endif

                     }

                     CameraSource::~CameraSource() {

                    @@ -288,6 +386,9 @@ status_t CameraSource::read(

                         sp<IMemory> frame;

                         int64_t frameTime;

                    +#if defined(OMAP_ENHANCEMENT) && (TARGET_OMAP4)

                    +    uint32_t frameOffset;

                    +#endif

                         {

                             Mutex::Autolock autoLock(mLock);

                             while (mStarted) {

                    @@ -302,6 +403,10 @@ status_t CameraSource::read(

                                 frame = *mFramesReceived.begin();

                                 mFramesReceived.erase(mFramesReceived.begin());

                    +#if defined(OMAP_ENHANCEMENT) && (TARGET_OMAP4)

                    +            frameOffset = *mFrameOffset.begin();

                    +            mFrameOffset.erase(mFrameOffset.begin());

                    +#endif

                                 frameTime = *mFrameTimes.begin();

                                 mFrameTimes.erase(mFrameTimes.begin());

                                 int64_t skipTimeUs;

                    @@ -326,6 +431,9 @@ status_t CameraSource::read(

                                     (*buffer)->add_ref();

                                     (*buffer)->meta_data()->setInt64(kKeyTime, frameTime);

                    +#if defined(OMAP_ENHANCEMENT) && (TARGET_OMAP4)

                    +                (*buffer)->meta_data()->setInt32(kKeyOffset, frameOffset);

                    +#endif

                                     return OK;

                                 }

                             }

                    @@ -333,8 +441,15 @@ status_t CameraSource::read(

                         return OK;

                     }

                    +#ifdef OMAP_ENHANCEMENT

                     void CameraSource::dataCallbackTimestamp(int64_t timestampUs,

                    -        int32_t msgType, const sp<IMemory> &data) {

                    +        int32_t msgType, const sp<IMemory> &data,

                    +        uint32_t offset, uint32_t stride)

                    +#else

                    +void CameraSource::dataCallbackTimestamp(int64_t timestampUs,

                    +        int32_t msgType, const sp<IMemory> &data)

                    +#endif

                    +{

                         LOGV("dataCallbackTimestamp: timestamp %lld us", timestampUs);

                         Mutex::Autolock autoLock(mLock);

                         if (!mStarted) {

                    @@ -373,6 +488,11 @@ void CameraSource::dataCallbackTimestamp(int64_t timestampUs,

                         mFrameTimes.push_back(timeUs);

                         LOGV("initial delay: %lld, current time stamp: %lld",

                             mStartTimeUs, timeUs);

                    +

                    +#if defined(OMAP_ENHANCEMENT) && (TARGET_OMAP4)

                    +    mFrameOffset.push_back(offset);

                    +#endif

                    +

                         mFrameAvailableCondition.signal();

                     }

media/libstagefright/DataSource.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -31,6 +31,10 @@

                     #include <media/stagefright/MediaErrors.h>

                     #include <utils/String8.h>

                    +#if defined(OMAP_ENHANCEMENT)

                    +#include "include/ASFExtractor.h"

                    +#endif

                    +

                     namespace android {

                     bool DataSource::getUInt16(off_t offset, uint16_t *x) {

                    @@ -104,6 +108,11 @@ void DataSource::RegisterDefaultSniffers() {

                         RegisterSniffer(SniffAMR);

                         RegisterSniffer(SniffMPEG2TS);

                         RegisterSniffer(SniffMP3);

                    +#ifdef OMAP_ENHANCEMENT

                    +    if(isASFParserAvailable()){

                    +        RegisterSniffer(SniffASF);

                    +    }

                    +#endif

                     }

                     // static

media/libstagefright/MPEG4Extractor.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -38,8 +38,44 @@

                     #include <media/stagefright/Utils.h>

                     #include <utils/String8.h>

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +#include "include/TISEIMessagesParser.h"

                    +#endif

                    +

                     namespace android {

                    +#ifdef OMAP_ENHANCEMENT

                    +#define POS_ESDS_CANT_BE_FOUND(chunk_size) (chunk_size - 3)

                    +/*Array containing the pointers to known types. This should be read only*/

                    +    static const struct Mpeg4FileType{

                    +        const char *const type;

                    +        const uint8_t size;

                    +    } knownFileTypes[] = {

                    +    {"ftyp3gp", 7},

                    +    {"ftypmp42", 8},

                    +    {"ftyp3gr6", 8},

                    +    {"ftyp3gs6", 8},

                    +    {"ftyp3ge6", 8},

                    +    {"ftyp3gg6", 8},

                    +    {"ftypiso", 7},

                    +    {"ftypM4V ", 8},

                    +    {"ftypM4A ", 8},

                    +    {"ftypf4v ", 8},

                    +    {"ftypkddi", 8},

                    +    {"ftypM4VP", 8},

                    +    {"ftypqt", 6},

                    +    {"ftypmmp4", 8},

                    +    {"ftypmp41", 8},

                    +    {"ftypwmf",  7},

                    +    {"ftypMSNV", 8},

                    +    {"ftyp3g2", 7},

                    +    {"ftypskm2",8},

                    +    {"ftypavc1",8}

                    +    };

                    +/*Indicates the number of known types and it should be linked to variable knownFileTypes*/

                    +#define NUMBER_OF_KNOWN_FILE_TYPES (sizeof(knownFileTypes)/sizeof(struct Mpeg4FileType))

                    +#endif

                    +

                     class MPEG4Source : public MediaSource {

                     public:

                         // Caller retains ownership of both "dataSource" and "sampleTable".

                    @@ -48,6 +84,9 @@ public:

                                     int32_t timeScale,

                                     const sp<SampleTable> &sampleTable);

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    virtual void parseSEIMessages(S3D_params &mS3Dparams);

                    +#endif

                         virtual status_t start(MetaData *params = NULL);

                         virtual status_t stop();

                    @@ -70,7 +109,9 @@ private:

                         bool mIsAVC;

                         size_t mNALLengthSize;

                    -

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    size_t SEINALLength;

                    +#endif

                         bool mStarted;

                         MediaBufferGroup *mGroup;

                    @@ -249,6 +290,10 @@ static const char *FourCC2MIME(uint32_t fourcc) {

                             case FOURCC('s', '2', '6', '3'):

                                 return MEDIA_MIMETYPE_VIDEO_H263;

                    +#ifdef OMAP_ENHANCEMENT

                    +        case FOURCC('H', '2', '6', '3'):

                    +            return MEDIA_MIMETYPE_VIDEO_H263;

                    +#endif

                             case FOURCC('a', 'v', 'c', '1'):

                                 return MEDIA_MIMETYPE_VIDEO_AVC;

                    @@ -323,7 +368,31 @@ sp<MetaData> MPEG4Extractor::getTrackMetaData(

                         if (track == NULL) {

                             return NULL;

                         }

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +    if (flags & kIncludeExtensiveMetaData){

                    +        track->includes_expensive_metadata = true;

                    +        const char *mime;

                    +        CHECK(track->meta->findCString(kKeyMIMEType, &mime));

                    +        if (!strncasecmp("video/", mime, 6)) {

                    +            uint32_t sampleIndex=0;

                    +            uint32_t sampleTime;

                    +            if (flags & kSelectFirstSample || track->sampleTable->findThumbnailSample(&sampleIndex) != OK){

                    +                /*It will be forced the frame zero which is supposed to

                    +                 *be an I frame every time.

                    +                 * */

                    +                LOGD("Forced first sample\n");

                    +                sampleIndex=0;

                    +            }

                    +            if (track->sampleTable->getMetaDataForSample(

                    +                        sampleIndex, NULL /* offset */, NULL /* size */,

                    +                        &sampleTime) == OK) {

                    +                track->meta->setInt64(

                    +                        kKeyThumbnailTime,

                    +                        ((int64_t)sampleTime * 1000000) / track->timescale);

                    +            }

                    +        }

                    +    }

                    +#else

                         if ((flags & kIncludeExtensiveMetaData)

                                 && !track->includes_expensive_metadata) {

                             track->includes_expensive_metadata = true;

                    @@ -343,7 +412,7 @@ sp<MetaData> MPEG4Extractor::getTrackMetaData(

                                 }

                             }

                         }

                    -

                    +#endif

                         return track->meta;

                     }

                    @@ -360,6 +429,36 @@ status_t MPEG4Extractor::readMetaData() {

                         if (mHaveMetadata) {

                             if (mHasVideo) {

                                 mFileMetaData->setCString(kKeyMIMEType, "video/mp4");

                    +#ifdef OMAP_ENHANCEMENT

                    +            Track *tempTrack = mFirstTrack;

                    +            int count = 0;

                    +            const char *mime;

                    +            while (tempTrack) {

                    +        CHECK(tempTrack->meta->findCString(kKeyMIMEType, &mime));

                    +

                    +        if (!strncasecmp("video/", mime, 6)) {

                    +

                    +          size_t totalframes;

                    +          int64_t duration;

                    +          int32_t dur32,fps;

                    +

                    +          fps = 0;

                    +                                        totalframes = tempTrack->sampleTable->countSamples();

                    +          tempTrack->meta->findInt64(kKeyDuration, &duration);

                    +

                    +          dur32 =  (int32_t) (duration / 1000000);

                    +                                        if(dur32 <=0){

                    +                                            //dur32 will be zero for clips < 1 second.

                    +                                            dur32 = 1;

                    +                                        }

                    +                                        fps = totalframes/dur32;

                    +                                        LOGV("totalframes %d duration %lld dur32 %d fps %d",totalframes,duration,dur32,fps);

                    +          tempTrack->meta->setInt32(kKeyVideoFPS,fps);

                    +        }

                    +        tempTrack= tempTrack->next;

                    +            }

                    +#endif

                    +

                             } else {

                                 mFileMetaData->setCString(kKeyMIMEType, "audio/mp4");

                             }

                    @@ -415,6 +514,12 @@ static void convertTimeToDate(int64_t time_1904, String8 *s) {

                     status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {

                         uint32_t hdr[2];

                    +#ifdef  OMAP_ENHANCEMENT

                    +    // A copy of the unmodified offset; needed to skip unrecognized

                    +    // atoms (unrecognized by this logic means that its name isn't

                    +    // recognized in the switch below)

                    +    off_t originalOffset=*offset;

                    +#endif

                         if (mDataSource->readAt(*offset, hdr, 8) < 8) {

                             return ERROR_IO;

                         }

                    @@ -433,11 +538,17 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {

                                 // The smallest valid chunk is 16 bytes long in this case.

                                 return ERROR_MALFORMED;

                             }

                    -    } else if (chunk_size < 8) {

                    +#ifdef OMAP_ENHANCEMENT

                    +    } else if ((chunk_size < 8) && (chunk_size != 0)){

                             // The smallest valid chunk is 8 bytes long.

                             return ERROR_MALFORMED;

                         }

                    -

                    +#else

                    +    } else if (chunk_size < 8){

                    +        // The smallest valid chunk is 8 bytes long.

                    +        return ERROR_MALFORMED;

                    +    }

                    +#endif

                         char chunk[5];

                         MakeFourCCString(chunk_type, chunk);

                    @@ -480,7 +591,28 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {

                             return OK;

                         }

                    +#ifdef OMAP_ENHANCEMENT

                    +    {

                    +        union {

                    +            uint32_t chunk;

                    +            uint8_t t[4];

                    +        }chnk;

                    +        chnk.chunk=chunk_type;

                    +        LOGV("Chunk: %c%c%c%c\n", chnk.t[3],chnk.t[2],chnk.t[1],chnk.t[0]);

                    +    }

                    +    // If the size of the atom is zero, then this is an empty atom that

                    +    //  needs to be skipped; the way to skip it is by making its size 4,

                    +    //  so the next time the instruction *offset += chunk_size happen

                    +    //  the atom be skipped and it doesn't cause the parser enter in

                    +    //  aninfinite loop.

                    +    //  (*offset would be pointing to the same place again and again if

                    +    //  chunk_size is zero)

                    +

                    +    if (!chunk_size){

                    +        chunk_size=4;

                    +    }

                    +#endif

                         switch(chunk_type) {

                             case FOURCC('m', 'o', 'o', 'v'):

                             case FOURCC('t', 'r', 'a', 'k'):

                    @@ -693,6 +825,153 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {

                             case FOURCC('m', 'p', '4', 'a'):

                             case FOURCC('s', 'a', 'm', 'r'):

                             case FOURCC('s', 'a', 'w', 'b'):

                    +#ifdef OMAP_ENHANCEMENT

                    +        {

                    +            // This pointer will hold the address of a buffer with the

                    +            // data content inside the mp4a, samr or sawb atoms.

                    +

                    +            uint8_t *buffer;

                    +

                    +            // Allocate buffer content

                    +

                    +            if (!(buffer = (uint8_t *)malloc(chunk_size))){

                    +                LOGD("Error allocating memory\n");

                    +                *offset += chunk_size;

                    +                return ERROR_OUT_OF_MEM;

                    +            }

                    +            // Fill out the buffer with the data

                    +

                    +            if (mDataSource->readAt(

                    +                        data_offset, buffer, chunk_size) < (ssize_t) chunk_size) {

                    +                free(buffer);

                    +                return ERROR_IO;

                    +            }

                    +            uint16_t data_ref_index = 0;

                    +            uint16_t num_channels = 0;

                    +            uint16_t sample_size = 0;

                    +            uint32_t sample_rate = 0;

                    +            if (chunk_size >= 25){

                    +                data_ref_index = U16_AT(&buffer[6]);

                    +                num_channels = U16_AT(&buffer[16]);

                    +

                    +                sample_size = U16_AT(&buffer[18]);

                    +                sample_rate = U32_AT(&buffer[24]) >> 16;

                    +            }

                    +

                    +            if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_AMR_NB,

                    +                            FourCC2MIME(chunk_type))) {

                    +                // AMR NB audio is always mono, 8kHz

                    +                num_channels = 1;

                    +                sample_rate = 8000;

                    +            } else if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_AMR_WB,

                    +                               FourCC2MIME(chunk_type))) {

                    +                // AMR WB audio is always mono, 16kHz

                    +                num_channels = 1;

                    +                sample_rate = 16000;

                    +            }

                    +

                    +            LOGV("*** coding='%s' %d channels, size %d, rate %d\n",

                    +                   chunk, num_channels, sample_size, sample_rate);

                    +

                    +            mLastTrack->meta->setCString(kKeyMIMEType, FourCC2MIME(chunk_type));

                    +            mLastTrack->meta->setInt32(kKeyChannelCount, num_channels);

                    +            mLastTrack->meta->setInt32(kKeySampleRate, sample_rate);

                    +

                    +            // The following section of code is like a parser that

                    +            // replaces the complete processing of the atoms mp4a, samr,

                    +            // and sawb.

                    +            // For each case, ideally there should be different parsers,

                    +            // but all should yield to the position of the esds atom.

                    +            // A search for a string is implemented (something like

                    +            // strstr but for chains that can have '\0' chars in the

                    +            // stream)

                    +            // In fact the code below is a modification of strstr

                    +

                    +

                    +            //s will store the position of the esds atom

                    +            uint8_t * s = (uint8_t *)buffer;

                    +            {

                    +                char c, sc;

                    +                // This is a modification of strstr; since

                    +                // '\0' is allowed, the stop logic will work

                    +                // by knowing the size of the array (instead of looking

                    +                // for '/0')

                    +

                    +                unsigned int count = 0;

                    +                // This is the tag that needs to be found.

                    +

                    +                const char * find = "esds";

                    +                c = *find++;

                    +                do {

                    +                    do {

                    +                        sc = *s++;

                    +                        count++;

                    +                    } while (sc != c && count < POS_ESDS_CANT_BE_FOUND(chunk_size));

                    +                } while ((memcmp(s, find, 3)) && count < POS_ESDS_CANT_BE_FOUND(chunk_size));

                    +                s--;

                    +            }

                    +

                    +            // The stop offset indicates the place where the current

                    +            // atom should end.

                    +

                    +            off_t stop_offset = *offset + chunk_size;

                    +            // Check if the parsing succeeded or not. If it didn't,

                    +            // there is still chance to properly play the file so no

                    +            // error will be reported, yet.

                    +

                    +            if (s==buffer + POS_ESDS_CANT_BE_FOUND(chunk_size)

                    +                || !(s-buffer)){

                    +                LOGD("esds not found continue parsing next atoms\n");

                    +                *offset = stop_offset;

                    +                free(buffer);

                    +                break;

                    +            }

                    +

                    +            // esds atom was found. Set the offset to the place where

                    +            // the atom was found, and rewind 4 bytes in order to seek

                    +            // from the place the atom's size is found.

                    +

                    +            *offset = data_offset + (s - buffer) - 4;

                    +

                    +            // Information found or not found, there is no need for

                    +            // the buffer anymore.

                    +

                    +            free(buffer);

                    +

                    +            // Parse esds atom

                    +

                    +            while (*offset < stop_offset) {

                    +                status_t err = parseChunk(offset, depth + 1);

                    +                if (err != OK) {

                    +                    // If the esds atom couldn't be parsed, then try to

                    +                    // continue parsing the other atoms and use the

                    +                    // default values.

                    +

                    +                    LOGD("Malformed\n");

                    +                    LOGD("Error while parsing audio metadata, should use default settings\n");

                    +                }

                    +            }

                    +

                    +            // This error will not be forgiven since this indicates

                    +            // the esds parser jumped above the size of the atom and

                    +            // attempted to read more information than what was

                    +            // contained in esds. (Case when the parser reads all the

                    +            // info and expects to find more, but it can't)

                    +            // However, if the offset is smaller, then the esds parser

                    +            // wasn't able to complete its parsing, this could be due

                    +            // to the fact it couldn't recognize a pattern in the esds

                    +            // atom; This indicates that some information could have

                    +            // been extracted from the esds, but not all and this parser

                    +            // will attempt to continue launching the application with

                    +            // the collected information (which may not be complete).

                    +

                    +            if (*offset > stop_offset) {

                    +                return ERROR_MALFORMED;

                    +            }

                    +

                    +            break;

                    +        }

                    +#else

                             {

                                 uint8_t buffer[8 + 20];

                                 if (chunk_data_size < (ssize_t)sizeof(buffer)) {

                    @@ -746,9 +1025,12 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {

                                 }

                                 break;

                             }

                    -

                    +#endif

                             case FOURCC('m', 'p', '4', 'v'):

                             case FOURCC('s', '2', '6', '3'):

                    +#ifdef OMAP_ENHANCEMENT

                    +        case FOURCC('H', '2', '6', '3'):

                    +#endif

                             case FOURCC('a', 'v', 'c', '1'):

                             {

                                 mHasVideo = true;

                    @@ -847,6 +1129,21 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {

                                 break;

                             }

                    +#ifdef OMAP_ENHANCEMENT

                    +        case FOURCC('c', 't', 't', 's'):

                    +        {

                    +            status_t err =

                    +                mLastTrack->sampleTable->setTimeToSampleParamsCtts(

                    +                        data_offset, chunk_data_size);

                    +

                    +            if (err != OK) {

                    +                return err;

                    +            }

                    +

                    +            *offset += chunk_size;

                    +            break;

                    +        }

                    +#endif

                             case FOURCC('s', 't', 't', 's'):

                             {

                                 status_t err =

                    @@ -910,6 +1207,11 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {

                                             &buffer[4], chunk_data_size - 4);

                                     if (err != OK) {

                    +#ifdef OMAP_ENHANCEMENT

                    +                    LOGD("Error retrieving audio metadata, attempt to "

                    +                    "continue by skipping the atom\n");

                    +                    *offset += chunk_size;

                    +#endif

                                         return err;

                                     }

                                 }

                    @@ -1020,9 +1322,29 @@ status_t MPEG4Extractor::parseChunk(off_t *offset, int depth) {

                                 break;

                             }

                    +#ifdef OMAP_ENHANCEMENT

                    +        case FOURCC('d', 'a', 'm', 'r'):

                    +        {

                    +             // validate chunk size of damr ATOM

                    +             if((chunk_data_size > 9)||(chunk_data_size < 0)){

                    +                 LOGV(" Chunk data size is INVALID ");

                    +                 return ERROR_MALFORMED;

                    +             }

                    +

                    +             *offset += chunk_size;

                    +             break;

                    +        }

                    +#endif

                    +

                             default:

                             {

                    +#ifdef OMAP_ENHANCEMENT

                    +            // Skip this unknown atom

                    +

                    +            *offset = originalOffset + chunk_size;

                    +#else

                                 *offset += chunk_size;

                    +#endif

                                 break;

                             }

                         }

                    @@ -1417,6 +1739,9 @@ MPEG4Source::MPEG4Source(

                           mCurrentSampleIndex(0),

                           mIsAVC(false),

                           mNALLengthSize(0),

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +      SEINALLength(0),

                    +#endif

                           mStarted(false),

                           mGroup(NULL),

                           mBuffer(NULL),

                    @@ -1450,6 +1775,88 @@ MPEG4Source::~MPEG4Source() {

                         }

                     }

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +void MPEG4Source::parseSEIMessages(S3D_params &mS3Dparams) {

                    +    status_t stats=0;

                    +

                    +    if (mIsAVC) {

                    +        int32_t max_size;

                    +        CHECK(mFormat->findInt32(kKeyMaxInputSize, &max_size));

                    +

                    +        int nalType, nalRefIdc;

                    +        status_t res;

                    +        size_t srcOffset = 0, size;

                    +

                    +        MediaBuffer *out = NULL;

                    +        uint8_t *myData;

                    +

                    +        status_t err = this->start();

                    +        if (err != OK)

                    +            goto EXIT;

                    +

                    +        err = read(&out);

                    +        if (err != OK)

                    +            goto EXIT;

                    +

                    +        myData = (uint8_t *)out->data();

                    +        // Getting the size read

                    +        size = out->size();

                    +        while (srcOffset < (size-4)) {

                    +            if((myData[srcOffset] == 0) &&

                    +                (myData[srcOffset+1] == 0) &&

                    +                (myData[srcOffset+2] == 0) &&

                    +                (myData[srcOffset+3] == 1))

                    +            {

                    +                srcOffset +=mNALLengthSize;

                    +                res = AVCGetNALType(&myData[srcOffset], (size-(srcOffset +mNALLengthSize)),&nalType, &nalRefIdc);

                    +                if (res)

                    +                {

                    +                    LOGE("FAILED Cannot determine nal type");

                    +                    goto EXIT;

                    +                }

                    +

                    +                switch (nalType)

                    +                {

                    +                    case AVC_NALTYPE_SEI:

                    +                    {

                    +                        LOGV("Calling DecodeSEI() \n");

                    +                        res = sei_rbsp(&myData[srcOffset], SEINALLength, mS3Dparams);//(size-(srcOffset +mNALLengthSize))

                    +                        if(res)

                    +                        {

                    +                            LOGE("FAILED parsing SEI messages \n");

                    +                            goto EXIT;

                    +                        }

                    +                        break;

                    +                    }

                    +                    default:

                    +                    {

                    +                        LOGV("Default value for NALType %d \n", nalType);

                    +                        break;

                    +                    }

                    +                }

                    +            }

                    +            else

                    +            {

                    +                srcOffset++;

                    +                if (srcOffset + mNALLengthSize>= size)

                    +                {

                    +                    LOGV("No more NAL Unit \n");

                    +                    goto EXIT;

                    +                }

                    +            }

                    +        }

                    +

                    +        EXIT:

                    +        if(out != NULL)

                    +        {

                    +            out->release();

                    +            out = NULL;myData=NULL;

                    +        }

                    +       this->stop();

                    +    }

                    +}

                    +#endif

                    +

                     status_t MPEG4Source::start(MetaData *params) {

                         Mutex::Autolock autoLock(mLock);

                    @@ -1530,7 +1937,9 @@ status_t MPEG4Source::read(

                         CHECK(mStarted);

                    +#if !defined(TARGET_OMAP4)

                         *out = NULL;

                    +#endif

                         int64_t targetSampleTimeUs = -1;

                    @@ -1618,7 +2027,11 @@ status_t MPEG4Source::read(

                         uint32_t dts;

                         bool isSyncSample;

                         bool newBuffer = false;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    if (mBuffer == NULL || (*out && !mWantsNALFragments)) {

                    +#else

                         if (mBuffer == NULL) {

                    +#endif

                             newBuffer = true;

                             status_t err =

                    @@ -1629,7 +2042,15 @@ status_t MPEG4Source::read(

                                 return err;

                             }

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +        if (NULL == *out || mWantsNALFragments) {

                    +            err = mGroup->acquire_buffer(&mBuffer);

                    +        } else {

                    +            mBuffer = *out;

                    +        }

                    +#else

                             err = mGroup->acquire_buffer(&mBuffer);

                    +#endif

                             if (err != OK) {

                                 CHECK(mBuffer == NULL);

                    @@ -1650,6 +2071,12 @@ status_t MPEG4Source::read(

                                 }

                                 CHECK(mBuffer != NULL);

                    +#ifdef OMAP_ENHANCEMENT

                    +            if(mSampleTable->mTimeToSampleCtts) {

                    +                dts += mSampleTable->mTimeToSampleCtts[mCurrentSampleIndex];

                    +            }

                    +#endif

                    +

                                 mBuffer->set_range(0, size);

                                 mBuffer->meta_data()->clear();

                                 mBuffer->meta_data()->setInt64(

                    @@ -1712,7 +2139,53 @@ status_t MPEG4Source::read(

                         } else {

                             // Whole NAL units are returned but each fragment is prefixed by

                             // the start code (0x00 00 00 01).

                    +#ifdef OMAP_ENHANCEMENT

                    +        uint8_t *dstData = (uint8_t *)mBuffer->data();

                    +        size_t srcOffset = 0;

                    +        size_t dstOffset = 0;

                    +

                    +        while (srcOffset < size) {

                    +            CHECK(srcOffset + mNALLengthSize <= size);

                    +            ssize_t num_bytes_read = mDataSource->readAt(offset+srcOffset, mSrcBuffer, mNALLengthSize);

                    +            if (num_bytes_read < (ssize_t)mNALLengthSize) {

                    +                mBuffer->release();

                    +                mBuffer = NULL;

                    +                return ERROR_IO;

                    +            }

                    +            size_t nalLength = parseNALSize(&mSrcBuffer[0]);

                    +            srcOffset += mNALLengthSize;

                    +            if (srcOffset + nalLength > size) {

                    +                mBuffer->release();

                    +                mBuffer = NULL;

                    +                return ERROR_MALFORMED;

                    +            }

                    +            if (nalLength == 0) {

                    +                continue;

                    +            }

                    +

                    +            CHECK(dstOffset + 4 <= mBuffer->size());

                    +

                    +            dstData[dstOffset++] = 0;

                    +            dstData[dstOffset++] = 0;

                    +            dstData[dstOffset++] = 0;

                    +            dstData[dstOffset++] = 1;

                    +            num_bytes_read = mDataSource->readAt(offset+srcOffset, &dstData[dstOffset], nalLength);

                    +            if (num_bytes_read < (ssize_t)nalLength) {

                    +                 mBuffer->release();

                    +                 mBuffer = NULL;

                    +                 return ERROR_IO;

                    +            }

                    +#if defined(TARGET_OMAP4)

                    +            // Getting NAL length for SEI messages Gilles

                    +            if(dstData[dstOffset] == AVC_NALTYPE_SEI)

                    +                SEINALLength = nalLength;

                    +#endif

                    +            srcOffset += nalLength;

                    +            dstOffset += nalLength;

                    +        }

                    +        CHECK_EQ(srcOffset, size);

                    +#else

                             ssize_t num_bytes_read =

                                 mDataSource->readAt(offset, mSrcBuffer, size);

                    @@ -1754,10 +2227,16 @@ status_t MPEG4Source::read(

                                 dstOffset += nalLength;

                             }

                             CHECK_EQ(srcOffset, size);

                    +#endif

                             CHECK(mBuffer != NULL);

                             mBuffer->set_range(0, dstOffset);

                             mBuffer->meta_data()->clear();

                    +#ifdef OMAP_ENHANCEMENT

                    +        if(mSampleTable->mTimeToSampleCtts)

                    +            dts = dts + mSampleTable->mTimeToSampleCtts[mCurrentSampleIndex];

                    +#endif

                    +

                             mBuffer->meta_data()->setInt64(

                                     kKeyTime, ((int64_t)dts * 1000000) / mTimescale);

                    @@ -1866,7 +2345,217 @@ static bool BetterSniffMPEG4(

                         return true;

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +bool positionFileAtAtom (const sp<DataSource> &source, uint32_t &offsetToNextAtom, const char *patern, off_t fileSize, uint32_t &atomSize) {

                    +    /*Fail safe counter*/

                    +    uint32_t failSafe = 0;

                    +    /*Stores the return value from comparations*/

                    +    int memCompRetVal;

                    +    /*Stores the analyzed atom's name and size*/

                    +    struct {

                    +        union {

                    +            uint32_t size;

                    +            uint8_t sizeArray[4];

                    +        } atomSize;

                    +        uint8_t  atomName[4];

                    +    } atomNameAndSize;

                    +

                    +    /*Check parameters*/

                    +

                    +    /*Init Atom Size to null*/

                    +    atomNameAndSize.atomSize.size = 0;

                    +

                    +    do {

                    +        /*increment the fail safe counter*/

                    +        failSafe++;

                    +

                    +        /*Jump to the next atom and read its type*/

                    +

                    +        /*Compute offset where the atom is stored*/

                    +        offsetToNextAtom += atomNameAndSize.atomSize.size;

                    +

                    +        /*Check the size is within the file size. Currently this is limited to a file of 2GB*/

                    +        if (fileSize > 0 && offsetToNextAtom >= (unsigned)fileSize) {

                    +            /*Bad offset*/

                    +            return false;

                    +        }

                    +

                    +

                    +        /*Read the cached info*/

                    +        if (source->readAt(offsetToNextAtom, &atomNameAndSize, sizeof(atomNameAndSize)) < (signed)sizeof(atomNameAndSize)) {

                    +            /*Couldnt read the atom's type and size*/

                    +            LOGD("Couldnt find next atom");

                    +            return false;

                    +        }

                    +

                    +        /*The size is in big endian, so it is necesary to convert the value so it can be used*/

                    +        /*Swap the framing bytes*/

                    +        atomNameAndSize.atomSize.sizeArray[0] ^= atomNameAndSize.atomSize.sizeArray[3];

                    +        atomNameAndSize.atomSize.sizeArray[3] ^= atomNameAndSize.atomSize.sizeArray[0];

                    +        atomNameAndSize.atomSize.sizeArray[0] ^= atomNameAndSize.atomSize.sizeArray[3];

                    +        /*Swap the middle bytes*/

                    +        atomNameAndSize.atomSize.sizeArray[1] ^= atomNameAndSize.atomSize.sizeArray[2];

                    +        atomNameAndSize.atomSize.sizeArray[2] ^= atomNameAndSize.atomSize.sizeArray[1];

                    +        atomNameAndSize.atomSize.sizeArray[1] ^= atomNameAndSize.atomSize.sizeArray[2];

                    +

                    +        LOGD("Atom found: %c%c%c%c with size = %x\n", atomNameAndSize.atomName[0], atomNameAndSize.atomName[1], atomNameAndSize.atomName[2], atomNameAndSize.atomName[3], atomNameAndSize.atomSize.size);

                    +    } while ((memCompRetVal = memcmp(atomNameAndSize.atomName, patern, 4))  && atomNameAndSize.atomSize.size && atomNameAndSize.atomSize.size >= 8 && failSafe < 10 && (offsetToNextAtom+atomNameAndSize.atomSize.size) < (unsigned)fileSize);

                    +

                    +

                    +    /*Check if the atom was found or that the iterations ended due to an error*/

                    +    if ((memCompRetVal) && ((offsetToNextAtom+atomNameAndSize.atomSize.size) < (unsigned)fileSize)) {

                    +        /*Didn't find it return with no success*/

                    +        return false;

                    +    }

                    +

                    +    /*If this point is reach the atom was found*/

                    +    atomSize = atomNameAndSize.atomSize.size;

                    +    return true;

                    +}

                    +

                    +bool SniffMPEG4(const sp<DataSource> &source, String8 *mimeType, float *confidence, sp<AMessage> *) {

                    +

                    +    /*Stores the ftyp type*/

                    +    uint8_t header[8];

                    +    /*Stores the return value from comparations*/

                    +    int memCompRetVal;

                    +

                    +    /*Read the header*/

                    +    if (source->readAt(4, header, sizeof(header)) < (signed)sizeof(header)) {

                    +        /*Couldnt read ftyp's atom's type*/

                    +        LOGD("Couldnt read ftyps atom type");

                    +        return false;

                    +    }

                    +

                    +    /*Look for known type headers*/

                    +    memCompRetVal = true;

                    +

                    +    for (int i = 0; i < NUMBER_OF_KNOWN_FILE_TYPES; i++) {

                    +        if (!(memCompRetVal = memcmp(header, knownFileTypes[i].type, knownFileTypes[i].size))) {

                    +            /*header has been found*/

                    +            break;

                    +        }

                    +    }

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +    bool mdat_result = memcmp(header, "mdat", 4);

                    +

                    +    /*Exit if the pattern wasn't found*/

                    +    if (memCompRetVal && mdat_result ) {

                    +#else

                    +    if (memCompRetVal) {

                    +#endif

                    +        /*Couldn't find the pattern*/

                    +#ifdef OMAP_ENHANCEMENT

                    +        LOGE("both mdat,ftyp not found");

                    +#endif

                    +        return false;

                    +    }

                    +

                    +    /*header has been found set the confidence to .1*/

                    +    *confidence=0.1f;

                    +    *mimeType = MEDIA_MIMETYPE_CONTAINER_MPEG4;

                    +

                    +    /*See if the confidence can be increased

                    +     *since the header was found the result will be true in any case

                    +     *the only thing that would change is the confidence.*/

                    +

                    +    /*The file type matched one in the known list, look for the track indicating a video handler*/

                    +    {

                    +        /*Stores the file size this is a signed value compared to the unsigned value used to store the atom's sizes*/

                    +        off_t fileSize;

                    +        /*Stores the computed offset to the new atom*/

                    +        uint32_t offsetToSeek;

                    +        /*Stores the atom's size*/

                    +        uint32_t atomSize;

                    +        /*fail safe counter*/

                    +        uint8_t failCounter;

                    +        /*Handler type*/

                    +        uint8_t handler[4];

                    +        /*Location of the first track atom*/

                    +        uint32_t trakOffset;

                    +        /*Stores the atom's track size*/

                    +        uint32_t trakSize;

                    +

                    +        /*Initialize the file size variable*/

                    +        if (source->getSize(&fileSize)) {

                    +            /*couldn't get the file size nor increase confidence*/

                    +            return true;

                    +        }

                    +

                    +        /*Look for the moov atom from the begining of the file*/

                    +        offsetToSeek = 0;

                    +

                    +        if (!positionFileAtAtom(source, offsetToSeek, "moov", fileSize, atomSize)) {

                    +            /*Couldn't find moov atom, return true as header was found*/

                    +            return true;

                    +        }

                    +

                    +        /*Once the moov atom has been found inspect each of the trak atoms looking for the vide handler*/

                    +        failCounter = 0;

                    +        /*Skip the header of the moov atom*/

                    +        offsetToSeek += 8;

                    +

                    +        do {

                    +            failCounter++;

                    +

                    +            if (!positionFileAtAtom(source, offsetToSeek, "trak", fileSize, atomSize)) {

                    +                /*Couldn't find trak atom, return true as the header was found*/

                    +                return true;

                    +            }

                    +

                    +            /*Store the position of the track atom and its size for future references*/

                    +            trakOffset = offsetToSeek;

                    +            trakSize = atomSize;

                    +

                    +            /*Look for the mdia atom inside the trak atom*/

                    +            /*Skip the header of the atom*/

                    +            offsetToSeek += 8;

                    +

                    +            if (!positionFileAtAtom(source, offsetToSeek, "mdia", fileSize, atomSize)) {

                    +                /*Couldn't find mdia atom, return true as header was found*/

                    +                return true;

                    +            }

                    +

                    +            /*Look for the hdlr atom inside the mdia atom*/

                    +            /*Skip the header of the atom*/

                    +            offsetToSeek += 8;

                    +

                    +            if (!positionFileAtAtom(source, offsetToSeek, "hdlr", fileSize, atomSize)) {

                    +                /*Couldn't find hdlr atom, return true as header was found*/

                    +                return true;

                    +            }

                    +

                    +            /*Read the handler*/

                    +            /*Adjust the offset to skip the null information*/

                    +            offsetToSeek += 0x10;

                    +

                    +            if (source->readAt(offsetToSeek, &handler, sizeof(handler)) < sizeof(handler)) {

                    +                /*Couldnt read the atom's type and size*/

                    +                LOGD("Couldnt read the handler");

                    +                return true;

                    +            }

                    +

                    +            /*Adjust the offset to look for the next trak atom*/

                    +            offsetToSeek = trakOffset + trakSize;

                    +        } while (memCompRetVal = memcmp(handler, "vide", 4) && failCounter < 10 && (offsetToSeek < fileSize));

                    +

                    +       /*For some clips which have only audio track, the above loop goes till the end of the file,

                    +       * without finding video handler, this is not an issue. And there is no string match for audio track,

                    +       * becuase such clips are found to be having NULL string for handler component name.

                    +       * Here the count 10 restricts us to allow the audio only clips having maximum of 10 tracks, which may be acceptable.

                    +       */

                    +        if ((memCompRetVal) && (offsetToSeek < fileSize)) {

                    +            return true;

                    +        }

                    +        /*Vide handler was found!!!*/

                    +        *confidence = 0.4;

                    +

                    +        return true;

                    +    }

                    +}

                    +#else

                     bool SniffMPEG4(

                             const sp<DataSource> &source, String8 *mimeType, float *confidence,

                             sp<AMessage> *) {

                    @@ -1881,6 +2570,6 @@ bool SniffMPEG4(

                         return false;

                     }

                    -

                    +#endif

                     }  // namespace android

media/libstagefright/MPEG4Writer.cpp 100644 → 100755

show inline notes
View file @ 1a6862f

            
                    @@ -41,6 +41,10 @@ namespace android {

                     static const int64_t kMax32BitFileSize = 0x007fffffffLL;

                     static const uint8_t kNalUnitTypeSeqParamSet = 0x07;

                     static const uint8_t kNalUnitTypePicParamSet = 0x08;

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +static const uint8_t kNalUnitTypeH264Sei = 0x06;

                    +static const uint8_t kNalUnitTypeH264IFrame = 0x5;

                    +#endif

                     // Using longer adjustment period to suppress fluctuations in

                     // the audio encoding paths

                    @@ -211,6 +215,19 @@ private:

                         Track(const Track &);

                         Track &operator=(const Track &);

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    bool misOutofOrderTimestamps;

                    +    struct TSTableEntry {

                    +        TSTableEntry(uint32_t count, uint64_t timestampUs)

                    +            : sampleCount(count), sampleTimestampUs(timestampUs) {}

                    +        uint32_t sampleCount;

                    +        uint64_t sampleTimestampUs;

                    +    };

                    +

                    +    List<TSTableEntry> mPresentationTimeStamp;

                    +    List<TSTableEntry> mDecodeTimeStamp;

                    +    void sortPresentationTimestamp(List<TSTableEntry> &DecodingTS);

                    +#endif

                     };

                     MPEG4Writer::MPEG4Writer(const char *filename)

                    @@ -714,6 +731,44 @@ static void StripStartcode(MediaBuffer *buffer) {

                             return;

                         }

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP3)

                    +    uint8_t *data =

                    +        (uint8_t *)buffer->data() + buffer->range_offset();

                    +    size_t size = buffer->range_length();

                    +    uint8_t *tmp = data;

                    +    uint8_t *foundStartData = data;

                    +    size_t bytesLeft = size;

                    +    size_t nal_size;

                    +    bool foundStartCode = false;

                    +

                    +    while (bytesLeft > 4) {

                    +        if (!memcmp("\x00\x00\x00\x01", tmp, 4)) {

                    +            if (tmp - foundStartData) {

                    +                if (foundStartCode == true) {

                    +                    nal_size = tmp - foundStartData - 4;

                    +                    foundStartData[0] = nal_size >> 24;

                    +                    foundStartData[1] = (nal_size >> 16) & 0xFF;

                    +                    foundStartData[2] = (nal_size >> 8) & 0xFF;

                    +                    foundStartData[3] = nal_size & 0xFF;

                    +                }

                    +                foundStartData = tmp;

                    +            }

                    +            foundStartCode = true;

                    +            tmp += 4;

                    +            bytesLeft -= 4;

                    +        } else {

                    +            bytesLeft--;

                    +            tmp++;

                    +        }

                    +    }

                    +    if (foundStartCode == true) {

                    +        nal_size = data + size - foundStartData - 4;

                    +        foundStartData[0] = nal_size >> 24;

                    +        foundStartData[1] = (nal_size >> 16) & 0xFF;

                    +        foundStartData[2] = (nal_size >> 8) & 0xFF;

                    +        foundStartData[3] = nal_size & 0xFF;

                    +    }

                    +#else

                         const uint8_t *ptr =

                             (const uint8_t *)buffer->data() + buffer->range_offset();

                    @@ -721,6 +776,7 @@ static void StripStartcode(MediaBuffer *buffer) {

                             buffer->set_range(

                                     buffer->range_offset() + 4, buffer->range_length() - 4);

                         }

                    +#endif

                     }

                     off_t MPEG4Writer::addLengthPrefixedSample_l(MediaBuffer *buffer) {

                    @@ -987,6 +1043,40 @@ void MPEG4Writer::Track::addOneSttsTableEntry(

                         mSttsTableEntries.push_back(sttsEntry);

                         ++mNumSttsTableEntries;

                     }

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +void MPEG4Writer::Track::sortPresentationTimestamp(List<TSTableEntry> &DecodingTS)

                    +{

                    +    int i, j, flag = 1;    // set flag to 1 to start first pass

                    +    TSTableEntry temp(0,0);             // holding variable

                    +    size_t numLength = DecodingTS.size();

                    +    List<TSTableEntry>::iterator it = DecodingTS.begin();

                    +    List<TSTableEntry>::iterator ittemp1;

                    +    List<TSTableEntry>::iterator ittemp2;

                    +    //Initalize the variable to zero

                    +    //Out of order flag should be set for Bframe

                    +    //scenario. If this is set the ctts structure

                    +    //preparation is mandatory.

                    +    misOutofOrderTimestamps = 0;

                    +    it = DecodingTS.begin();

                    +    for(i = 1; (i <= numLength) && flag; i++) {

                    +        ittemp1 = it;

                    +        flag = 0;

                    +        for (j = 0; j < (numLength -1); j++) {

                    +            ittemp2 = ittemp1;

                    +            ittemp1 ++;

                    +            if (ittemp1->sampleTimestampUs < ittemp2->sampleTimestampUs){

                    +                temp = *ittemp2;             // swap elements

                    +                *ittemp2 = *ittemp1;

                    +                *ittemp1 = temp;

                    +                flag = 1;               // indicates that a swap occurred.

                    +                //This means that we have out of order

                    +                //timestamps and bframes are present

                    +                misOutofOrderTimestamps = 1;

                    +            }

                    +        }

                    +    }

                    +}

                    +#endif

                     void MPEG4Writer::Track::addChunkOffset(off_t offset) {

                         ++mNumStcoTableEntries;

                    @@ -1103,9 +1193,13 @@ void MPEG4Writer::writeFirstChunk(ChunkInfo* info) {

                         for (List<MediaBuffer *>::iterator it = chunkIt->mSamples.begin();

                              it != chunkIt->mSamples.end(); ++it) {

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP3)

                    +        off_t offset = addSample_l(*it);

                    +#else

                             off_t offset = info->mTrack->isAvc()

                                                 ? addLengthPrefixedSample_l(*it)

                                                 : addSample_l(*it);

                    +#endif

                             if (it == chunkIt->mSamples.begin()) {

                                 info->mTrack->addChunkOffset(offset);

                             }

                    @@ -1338,6 +1432,48 @@ static const uint8_t *findNextStartCode(

                         return &data[length - bytesLeft];

                     }

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +static const uint16_t getLengthNalUnit(

                    +        const uint8_t *data, size_t length) {

                    +

                    +    LOGV("getLengthNalUnit: %p %d", data, length);

                    +

                    +    size_t bytesLeft = length;

                    +    uint16_t NalUnitLength = 0;

                    +    while (bytesLeft > 4  &&

                    +            memcmp("\x00\x00\x00\x01", &data[length - bytesLeft], 4)) {

                    +        --bytesLeft;

                    +        NalUnitLength++;

                    +    }

                    +    return (NalUnitLength + 4);

                    +}

                    +

                    +static void StripSpsPps(MediaBuffer *buffer) {

                    +   const uint8_t *ptr = (const uint8_t *)buffer->data() + buffer->range_offset();

                    +   const uint8_t *nextStartCode = ptr;

                    +   size_t bytesLeft = buffer->range_length();

                    +   uint8_t type = 0;

                    +   uint16_t nalLength = 0;

                    +

                    +    while (bytesLeft > 4 && !memcmp("\x00\x00\x00\x01", ptr, 4)) {

                    +        getNalUnitType(*(ptr + 4), &type);

                    +        if (type == kNalUnitTypeH264IFrame) {

                    +            LOGV("Got the sync frame. Break out.");

                    +            break;

                    +        }

                    +        // Strip SPS, PPS or SEI info if any

                    +        else if (type == kNalUnitTypeSeqParamSet || type == kNalUnitTypePicParamSet ) {

                    +            nalLength = getLengthNalUnit(ptr+4,bytesLeft-4);

                    +            LOGV("Stripping Nal Type 0x%x, Nal-Length %d",type,nalLength);

                    +            buffer->set_range(buffer->range_offset() + nalLength, buffer->range_length() - nalLength);

                    +        }

                    +        nextStartCode = findNextStartCode(ptr+4,bytesLeft-4);

                    +        bytesLeft -= nextStartCode - ptr;

                    +        ptr = nextStartCode;

                    +    }

                    +}

                    +#endif

                    +

                     const uint8_t *MPEG4Writer::Track::parseParamSet(

                             const uint8_t *data, size_t length, int type, size_t *paramSetLen) {

                    @@ -1474,8 +1610,13 @@ status_t MPEG4Writer::Track::parseAVCCodecSpecificData(

                         {

                             // Check on the profiles

                             // These profiles requires additional parameter set extensions

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +

                    +        if (mProfileIdc == 110 || mProfileIdc == 122 || mProfileIdc == 144) {

                    +#else

                             if (mProfileIdc == 100 || mProfileIdc == 110 ||

                                 mProfileIdc == 122 || mProfileIdc == 144) {

                    +#endif

                                 LOGE("Sorry, no support for profile_idc: %d!", mProfileIdc);

                                 return BAD_VALUE;

                             }

                    @@ -1710,6 +1851,10 @@ status_t MPEG4Writer::Track::threadEntry() {

                         uint32_t previousSampleSize = 0;  // Size of the previous sample

                         int64_t previousPausedDurationUs = 0;

                         int64_t timestampUs;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)

                    +    uint8_t *copy_spspps;

                    +    int32_t copy_spspps_size = 0;

                    +#endif

                         if (mIsAudio) {

                             prctl(PR_SET_NAME, (unsigned long)"AudioTrackEncoding", 0, 0, 0);

                    @@ -1766,20 +1911,112 @@ status_t MPEG4Writer::Track::threadEntry() {

                                 mGotAllCodecSpecificData = true;

                                 continue;

                             }

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)

                    +        else if (mIsAvc && count < 3) {

                    +            size_t size = buffer->range_length();

                    +            size_t start_code_size = 0;

                    +

                    +            CHECK(!mGotAllCodecSpecificData);

                    +

                    +            start_code_size = memcmp("\x00\x00\x00\x01",

                    +                    (uint8_t *)buffer->data(), 4) ? 4 : 0;

                    +

                    +            switch (count) {

                    +                case 1:

                    +                {

                    +                    copy_spspps = (uint8_t *)malloc(size + start_code_size);

                    +                    copy_spspps_size = size + start_code_size;

                    +                    if (start_code_size)

                    +                        memcpy(copy_spspps,

                    +                                "\x00\x00\x00\x01", start_code_size);

                    +                    memcpy((uint8_t *)copy_spspps + start_code_size,

                    +                            (const uint8_t *)buffer->data()

                    +                                + buffer->range_offset(),

                    +                            size);

                    +                    break;

                    +                }

                    +

                    +                case 2:

                    +                {

                    +                    size_t offset = copy_spspps_size;

                    +                    copy_spspps_size += (size + start_code_size);

                    +                    copy_spspps = (uint8_t *)realloc(copy_spspps, copy_spspps_size);

                    +                    if (start_code_size)

                    +                        memcpy(&copy_spspps[offset],

                    +                                "\x00\x00\x00\x01", start_code_size);

                    +                    memcpy(&copy_spspps[offset + start_code_size],

                    +                            (const uint8_t *)buffer->data()

                    +                                + buffer->range_offset(),

                    +                            size);

                    +                    status_t err = makeAVCCodecSpecificData(

                    +                            copy_spspps, copy_spspps_size);

                    +                    CHECK_EQ(OK, err);

                    +                    free(copy_spspps);

                    +                    copy_spspps = NULL;

                    +                    mGotAllCodecSpecificData = true;

                    +                    break;

                    +                }

                    +            }

                    +

                    +            buffer->release();

                    +            buffer = NULL;

                    +

                    +            continue;

                    +

                    +        } else if (mCodecSpecificData == NULL && mIsMPEG4) {

                    +            CHECK(!mGotAllCodecSpecificData);

                    +            mCodecSpecificDataSize = buffer->range_length();

                    +            mCodecSpecificData = malloc(mCodecSpecificDataSize);

                    +            memcpy(mCodecSpecificData,

                    +                    (const uint8_t *)buffer->data()

                    +                        + buffer->range_offset(),

                    +                   buffer->range_length());

                    +            buffer->release();

                    +            buffer = NULL;

                    +

                    +            mGotAllCodecSpecificData = true;

                    +            continue;

                    +        }

                    +#endif

                             // Make a deep copy of the MediaBuffer and Metadata and release

                             // the original as soon as we can

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP3)

                    +        MediaBuffer *copy;

                    +        size_t start_code_size = 0;

                    +

                    +        if (mIsAvc) {

                    +            start_code_size = memcmp("\x00\x00\x00\x01",

                    +                    (uint8_t *)buffer->data(), 4) ? 4 : 0;

                    +        }

                    +        copy = new MediaBuffer(buffer->range_length() + start_code_size);

                    +        if (start_code_size)

                    +            memcpy(copy->data(), "\x00\x00\x00\x01", start_code_size);

                    +        memcpy((uint8_t *)copy->data() + start_code_size,

                    +                (uint8_t *)buffer->data() + buffer->range_offset(),

                    +                buffer->range_length());

                    +        copy->set_range(0, buffer->range_length() + start_code_size);

                    +#else

                             MediaBuffer *copy = new MediaBuffer(buffer->range_length());

                             memcpy(copy->data(), (uint8_t *)buffer->data() + buffer->range_offset(),

                                     buffer->range_length());

                             copy->set_range(0, buffer->range_length());

                    +#endif

                             meta_data = new MetaData(*buffer->meta_data().get());

                             buffer->release();

                             buffer = NULL;

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +        int32_t isSync1 = 0;

                    +        meta_data->findInt32(kKeyIsSyncFrame, &isSync1);

                    +

                    +        if (mIsAvc && isSync1) StripSpsPps(copy);

                    +#endif

                    +

                             if (mIsAvc) StripStartcode(copy);

                             size_t sampleSize = copy->range_length();

                    +#if !defined (OMAP_ENHANCEMENT) || !defined (TARGET_OMAP3)

                             if (mIsAvc) {

                                 if (mOwner->useNalLengthFour()) {

                                     sampleSize += 4;

                    @@ -1787,6 +2024,7 @@ status_t MPEG4Writer::Track::threadEntry() {

                                     sampleSize += 2;

                                 }

                             }

                    +#endif

                             // Max file size or duration handling

                             mMdatSizeBytes += sampleSize;

                    @@ -1863,6 +2101,7 @@ status_t MPEG4Writer::Track::threadEntry() {

                             CHECK(timestampUs >= 0);

                             if (mNumSamples > 1) {

                    +#if !defined(OMAP_ENHANCEMENT) && !defined(TARGET_OMAP4)

                                 if (timestampUs <= lastTimestampUs) {

                                     LOGW("Frame arrives too late!");

                                     // Don't drop the late frame, since dropping a frame may cause

                    @@ -1876,6 +2115,7 @@ status_t MPEG4Writer::Track::threadEntry() {

                                         timestampUs = lastTimestampUs + (1000000LL + (mTimeScale >> 1)) / mTimeScale;

                                     }

                                 }

                    +#endif

                             }

                             LOGV("%s media time stamp: %lld and previous paused duration %lld",

                    @@ -1897,7 +2137,18 @@ status_t MPEG4Writer::Track::threadEntry() {

                                          (lastTimestampUs * mTimeScale + 500000LL) / 1000000LL);

                                 if (currDurationTicks != lastDurationTicks) {

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +            if(!mIsAudio) {

                    +                //Collect timestamps

                    +                TSTableEntry sample(sampleCount,lastTimestampUs);

                    +                mPresentationTimeStamp.push_back(sample);

                    +                mDecodeTimeStamp.push_back(sample);

                    +            } else {

                                     addOneSttsTableEntry(sampleCount, lastDurationUs);

                    +            }

                    +#else

                    +                addOneSttsTableEntry(sampleCount, lastDurationUs);

                    +#endif

                                     sampleCount = 1;

                                 } else {

                                     ++sampleCount;

                    @@ -1924,8 +2175,12 @@ status_t MPEG4Writer::Track::threadEntry() {

                                 trackProgressStatus(timestampUs);

                             }

                             if (mOwner->numTracks() == 1) {

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP3)

                    +            off_t offset = mOwner->addSample_l(copy);

                    +#else

                                 off_t offset = mIsAvc? mOwner->addLengthPrefixedSample_l(copy)

                                                      : mOwner->addSample_l(copy);

                    +#endif

                                 if (mChunkOffsets.empty()) {

                                     addChunkOffset(offset);

                                 }

                    @@ -1980,7 +2235,19 @@ status_t MPEG4Writer::Track::threadEntry() {

                         } else {

                             ++sampleCount;  // Count for the last sample

                         }

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    if(!mIsAudio) {

                    +        //Collect timestamps

                    +        TSTableEntry sample(sampleCount,lastTimestampUs);

                    +        mPresentationTimeStamp.push_back(sample);

                    +        mDecodeTimeStamp.push_back(sample);

                    +    } else {

                    +        addOneSttsTableEntry(sampleCount, lastDurationUs);

                    +    }

                    +#else

                         addOneSttsTableEntry(sampleCount, lastDurationUs);

                    +#endif

                    +

                         mTrackDurationUs += lastDurationUs;

                         mReachedEOS = true;

                         LOGI("Received total/0-length (%d/%d) buffers and encoded %d frames. - %s",

                    @@ -2413,6 +2680,37 @@ void MPEG4Writer::Track::writeTrackHeader(

                               mOwner->endBox();  // stsd

                               mOwner->beginBox("stts");

                    +

                    + #if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +            if(!mIsAudio) { // ctts is valid only for video

                    +

                    +                //Make sure that the Stts value is sorted and

                    +                //is in increasing order. As per standard stts

                    +                //cannot be negative so unless we sort the out

                    +                //of order timestamp the duration encoding will

                    +                //not be positive.

                    +                // stts[n] = dts[n+1] - dts[n]

                    +                sortPresentationTimestamp(mDecodeTimeStamp);

                    +

                    +                //Need to add First frame time stamp as zero

                    +                //for the Iframe encoding

                    +                TSTableEntry temp (1,0);

                    +                mDecodeTimeStamp.push_front(temp);

                    +

                    +                //Update the duration in stts stucture.

                    +                uint32_t countDecodeTSList = mDecodeTimeStamp.size();

                    +                List<TSTableEntry>::iterator itcur = mDecodeTimeStamp.begin();

                    +                List<TSTableEntry>::iterator itnext = itcur;

                    +                itnext ++;

                    +                for (uint32_t i = 1; i < countDecodeTSList; i++) {

                    +                    addOneSttsTableEntry(itnext->sampleCount, (itnext->sampleTimestampUs - itcur->sampleTimestampUs) / itnext->sampleCount);

                    +                    itnext ++;

                    +                    itcur ++;

                    +                }

                    +

                    +            }

                    + #endif

                    +

                                 mOwner->writeInt32(0);  // version=0, flags=0

                                 mOwner->writeInt32(mNumSttsTableEntries);

                                 int64_t prevTimestampUs = 0;

                    @@ -2431,6 +2729,33 @@ void MPEG4Writer::Track::writeTrackHeader(

                                 }

                               mOwner->endBox();  // stts

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +        if(!mIsAudio && misOutofOrderTimestamps) {

                    +            LOGE("Out of order detected!");

                    +            mOwner->beginBox("ctts");

                    +            mOwner->writeInt32(0);  // version=0, flags=0

                    +            mOwner->writeInt32(mDecodeTimeStamp.size());

                    +

                    +            // Write first sample for Iframe as zero

                    +            mOwner->writeInt32(1);

                    +            mOwner->writeInt32(0);

                    +

                    +            // Encode the offset of ctts as difference between presentation timestamp

                    +            // and decoding timestamp.

                    +            size_t countPresentationTSList = mPresentationTimeStamp.size();

                    +            List<TSTableEntry>::iterator itpresentation = mPresentationTimeStamp.begin();

                    +            List<TSTableEntry>::iterator itdecoding     = mDecodeTimeStamp.begin();

                    +            for (size_t i = 0; i < countPresentationTSList; ++i) {

                    +                mOwner->writeInt32(itdecoding->sampleCount);

                    +                int32_t dur =  ((itpresentation->sampleTimestampUs * mTimeScale + 500000LL) / 1000000LL -

                    +                             (itdecoding->sampleTimestampUs * mTimeScale + 500000LL) / 1000000LL);

                    +                itpresentation ++;

                    +                itdecoding ++;

                    +                mOwner->writeInt32(dur);

                    +            }

                    +          mOwner->endBox();  // ctts

                    +        }

                    +#endif

                               if (!mIsAudio) {

                                 mOwner->beginBox("stss");

                                   mOwner->writeInt32(0);  // version=0, flags=0

media/libstagefright/MediaBuffer.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -112,10 +112,25 @@ size_t MediaBuffer::range_length() const {

                     }

                     void MediaBuffer::set_range(size_t offset, size_t length) {

                    +#ifdef OMAP_ENHANCEMENT

                    +    if(offset) {

                    +        if (offset + length > mSize) {

                    +            LOGE("offset = %d, length = %d, mSize = %d", offset, length, mSize);

                    +        }

                    +        CHECK(offset + length <= mSize);

                    +    }

                    +    else {

                    +        if (length > mSize) {

                    +            LOGE("offset = %d, length = %d, mSize = %d", offset, length, mSize);

                    +            length = mSize;

                    +        }

                    +    }

                    +#else

                         if (offset + length > mSize) {

                             LOGE("offset = %d, length = %d, mSize = %d", offset, length, mSize);

                         }

                         CHECK(offset + length <= mSize);

                    +#endif

                         mRangeOffset = offset;

                         mRangeLength = length;

media/libstagefright/MediaDefs.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -25,6 +25,17 @@ const char *MEDIA_MIMETYPE_VIDEO_AVC = "video/avc";

                     const char *MEDIA_MIMETYPE_VIDEO_MPEG4 = "video/mp4v-es";

                     const char *MEDIA_MIMETYPE_VIDEO_H263 = "video/3gpp";

                     const char *MEDIA_MIMETYPE_VIDEO_RAW = "video/raw";

                    +#if defined(OMAP_ENHANCEMENT)

                    +#if  defined(TARGET_OMAP4)

                    +const char *MEDIA_MIMETYPE_VIDEO_VP6 = "video/x-vp6";

                    +const char *MEDIA_MIMETYPE_VIDEO_VP7 = "video/x-vp7";

                    +#endif

                    +const char *MEDIA_MIMETYPE_CONTAINER_ASF = "video/asf";

                    +const char *MEDIA_MIMETYPE_VIDEO_WMV  = "video/wmv9";

                    +const char *MEDIA_MIMETYPE_AUDIO_WMA = "audio/wma";

                    +const char *MEDIA_MIMETYPE_AUDIO_WMAPRO = "audio/wmapro";

                    +const char *MEDIA_MIMETYPE_AUDIO_WMALSL = "audio/wmalsl";

                    +#endif

                     const char *MEDIA_MIMETYPE_AUDIO_AMR_NB = "audio/3gpp";

                     const char *MEDIA_MIMETYPE_AUDIO_AMR_WB = "audio/amr-wb";

                    @@ -39,7 +50,11 @@ const char *MEDIA_MIMETYPE_AUDIO_RAW = "audio/raw";

                     const char *MEDIA_MIMETYPE_CONTAINER_MPEG4 = "video/mpeg4";

                     const char *MEDIA_MIMETYPE_CONTAINER_WAV = "audio/wav";

                     const char *MEDIA_MIMETYPE_CONTAINER_OGG = "application/ogg";

                    +

                     const char *MEDIA_MIMETYPE_CONTAINER_MATROSKA = "video/x-matroska";

                     const char *MEDIA_MIMETYPE_CONTAINER_MPEG2TS = "video/mp2ts";

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +const char *MEDIA_MIMETYPE_CONTAINER_AVI = "video/x-msvideo";

                    +#endif

                     }  // namespace android

media/libstagefright/MediaExtractor.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -34,6 +34,10 @@

                     #include <media/stagefright/MetaData.h>

                     #include <utils/String8.h>

                    +#ifdef OMAP_ENHANCEMENT

                    +#include "include/ASFExtractor.h"

                    +#endif

                    +

                     namespace android {

                     sp<MetaData> MediaExtractor::getMetaData() {

                    @@ -80,6 +84,16 @@ sp<MediaExtractor> MediaExtractor::Create(

                         } else if (!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_MPEG2TS)) {

                             return new MPEG2TSExtractor(source);

                         }

                    +#ifdef OMAP_ENHANCEMENT

                    +    else if(!strcasecmp(mime, MEDIA_MIMETYPE_CONTAINER_ASF)) {

                    +        if(isASFParserAvailable()) {

                    +            return new ASFExtractor(source);

                    +        }

                    +        else {

                    +            return NULL;

                    +        }

                    +    }

                    +#endif

                         return NULL;

                     }

media/libstagefright/MediaSource.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -37,10 +37,23 @@ void MediaSource::ReadOptions::reset() {

                     void MediaSource::ReadOptions::setSeekTo(int64_t time_us, SeekMode mode) {

                         mOptions |= kSeekTo_Option;

                    +#ifdef OMAP_ENHANCEMENT

                    +    //Incase the app layer tries to seek to negative offset,

                    +    //resetting the value to Zero.

                    +    if (time_us < 0)

                    +    {

                    +        time_us = 0;

                    +    }

                    +#endif

                         mSeekTimeUs = time_us;

                         mSeekMode = mode;

                     }

                    +extern "C" void _ZN7android11MediaSource11ReadOptions9setSeekToExNS1_8SeekModeE(int64_t time_us, void *mode);

                    +extern "C" void _ZN7android11MediaSource11ReadOptions9setSeekToEx(int64_t time_us) {

                    +    _ZN7android11MediaSource11ReadOptions9setSeekToExNS1_8SeekModeE(time_us, NULL);

                    +}

                    +

                     void MediaSource::ReadOptions::clearSeekTo() {

                         mOptions &= ~kSeekTo_Option;

                         mSeekTimeUs = 0;

media/libstagefright/NuCachedSource2.cpp 100644 → 100755

show inline notes
View file @ 1a6862f

            
                    @@ -327,7 +327,11 @@ void NuCachedSource2::onRead(const sp<AMessage> &msg) {

                     }

                     void NuCachedSource2::restartPrefetcherIfNecessary_l(bool force) {

                    +#ifndef OMAP_ENHANCEMENT

                         static const size_t kGrayArea = 256 * 1024;

                    +#else

                    +    static const size_t kGrayArea = 256 * 1024 * 12;

                    +#endif

                         if (mFetching || mFinalStatus != OK) {

                             return;

                    @@ -435,8 +439,12 @@ ssize_t NuCachedSource2::readInternal(off_t offset, void *data, size_t size) {

                         if (offset < mCacheOffset

                                 || offset >= (off_t)(mCacheOffset + mCache->totalSize())) {

                    +#ifndef OMAP_ENHANCEMENT

                             static const off_t kPadding = 32768;

                    -

                    +#else

                    +        // make this value larger for high profile playback

                    +        static const off_t kPadding = 768 * 1024;

                    +#endif

                             // In the presence of multiple decoded streams, once of them will

                             // trigger this seek request, the other one will request data "nearby"

                             // soon, adjust the seek position so that that subsequent request

                    @@ -447,6 +455,13 @@ ssize_t NuCachedSource2::readInternal(off_t offset, void *data, size_t size) {

                         }

                         size_t delta = offset - mCacheOffset;

                    +#ifdef OMAP_ENHANCEMENT

                    +    if (offset + size <= mCacheOffset + mCache->totalSize()) {

                    +        mCache->copy(delta, data, size);

                    +

                    +        return size;

                    +    }

                    +#endif

                         if (mFinalStatus != OK) {

                             if (delta >= mCache->totalSize()) {

                    @@ -459,11 +474,13 @@ ssize_t NuCachedSource2::readInternal(off_t offset, void *data, size_t size) {

                             return avail;

                         }

                    +#ifndef OMAP_ENHANCEMENT

                         if (offset + size <= mCacheOffset + mCache->totalSize()) {

                             mCache->copy(delta, data, size);

                             return size;

                         }

                    +#endif

                         LOGV("deferring read");

media/libstagefright/OMXCodec.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -35,6 +35,10 @@

                     #include "include/ESDS.h"

                    +#if defined(OMAP_ENHANCEMENT) && (TARGET_OMAP4)

                    +#define NPA_BUFFERS

                    +#endif

                    +

                     #include <binder/IServiceManager.h>

                     #include <binder/MemoryDealer.h>

                     #include <binder/ProcessState.h>

                    @@ -60,6 +64,79 @@

                     #endif

                     #include "include/ThreadedSource.h"

                    +#ifdef OMAP_ENHANCEMENT

                    +#include <overlay_common.h>

                    +#include <cutils/properties.h>

                    +#ifdef TARGET_OMAP4

                    +#include <TICameraParameters.h>

                    +

                    +#include "OMX_TI_Index.h"

                    +#include "OMX_TI_Common.h"

                    +#include "OMX_TI_Video.h"

                    +#include "OMX_TI_IVCommon.h"

                    +#endif

                    +

                    +/**

                    +* Important Note#

                    +* Method to calculate the reference frames required for decoder on output port

                    +* This is as per standard, hence no changes are expected in this function logic in the future

                    +* But for any changes done inside Codec, it is required to update here as well as in

                    +* TIHardwareRenderer.cpp (platform/hardware/ti/omap3/libstagefrighthw)

                    +* And this will be removed once flash backward compatibity issue is resolved.

                    +*/

                    +static int Calculate_TotalRefFrames(int nWidth, int nHeight) {

                    +    LOGD("Calculate_TotalRefFrames");

                    +    uint32_t ref_frames = 0;

                    +    uint32_t MaxDpbMbs;

                    +    uint32_t PicWidthInMbs;

                    +    uint32_t FrameHeightInMbs;

                    +

                    +    MaxDpbMbs = 32768; //Maximum value for upto level 4.1

                    +

                    +    PicWidthInMbs = nWidth / 16;

                    +

                    +    FrameHeightInMbs = nHeight / 16;

                    +

                    +    ref_frames =  (uint32_t)(MaxDpbMbs / (PicWidthInMbs * FrameHeightInMbs));

                    +

                    +    LOGD("nWidth [%d] PicWidthInMbs [%d] nHeight [%d] FrameHeightInMbs [%d] ref_frames [%d]",

                    +          nWidth, PicWidthInMbs, nHeight, FrameHeightInMbs, ref_frames);

                    +

                    +    ref_frames = (ref_frames > 16) ? 16 : ref_frames;

                    +

                    +    LOGD("Final ref_frames [%d]",  ref_frames);

                    +

                    +    return (ref_frames + 3 + 2*NUM_BUFFERS_TO_BE_QUEUED_FOR_OPTIMAL_PERFORMANCE);

                    +}

                    +

                    +#if defined NPA_BUFFERS

                    +#define OMX_BUFFERHEADERFLAG_MODIFIED 0x00000100

                    +#define THUMBNAIL_BUFFERS_NPA_MODE 2

                    +#define NPA_BUFFER_SIZE 4

                    +#endif

                    +

                    +#ifdef TARGET_OMAP4

                    +#define SUPPORT_B_FRAMES

                    +#ifdef SUPPORT_B_FRAMES

                    +#define OMX_NUM_B_FRAMES 2

                    +#else

                    +#define OMX_NUM_B_FRAMES 0

                    +#endif

                    +#define OUTPUT_BUFFER_COUNT 2

                    +#define INPUT_BUFFER_COUNT 2

                    +#elif defined(TARGET_OMAP3)

                    +#if defined(OVERLAY_NUM_REQBUFFERS)

                    +#define OUTPUT_BUFFER_COUNT OVERLAY_NUM_REQBUFFERS

                    +#else

                    +#define OUTPUT_BUFFER_COUNT 4

                    +#endif

                    +#endif

                    +

                    +#endif

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +#include <overlay_common.h>

                    +#endif

                     namespace android {

                    @@ -157,6 +234,78 @@ static sp<MediaSource> InstantiateSoftwareCodec(

                     #undef FACTORY_REF

                     #undef FACTORY_CREATE

                    +#ifdef OMAP_ENHANCEMENT

                    +#ifdef TARGET_OMAP4

                    +//Enable Ducati Codecs for Video, PV SW codecs for Audio

                    +static const CodecInfo kDecoderInfo[] = {

                    +    { MEDIA_MIMETYPE_AUDIO_MPEG, "MP3Decoder" },

                    +    { MEDIA_MIMETYPE_AUDIO_AMR_NB, "AMRNBDecoder" },

                    +    { MEDIA_MIMETYPE_AUDIO_AMR_WB, "AMRWBDecoder" },

                    +    { MEDIA_MIMETYPE_AUDIO_AAC, "AACDecoder" },

                    +    { MEDIA_MIMETYPE_VIDEO_WMV, "OMX.TI.DUCATI1.VIDEO.DECODER" },

                    +    { MEDIA_MIMETYPE_AUDIO_WMA, "OMX.ITTIAM.WMA.decode" },

                    +    { MEDIA_MIMETYPE_AUDIO_WMALSL, "OMX.ITTIAM.WMALSL.decode" },

                    +    { MEDIA_MIMETYPE_AUDIO_WMAPRO, "OMX.ITTIAM.WMAPRO.decode" },

                    +    { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.TI.DUCATI1.VIDEO.DECODER" },

                    +    { MEDIA_MIMETYPE_VIDEO_MPEG4, "M4vH263Decoder" },

                    +    { MEDIA_MIMETYPE_VIDEO_H263, "OMX.TI.DUCATI1.VIDEO.DECODER" },

                    +    { MEDIA_MIMETYPE_VIDEO_H263, "M4vH263Decoder" },

                    +    { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.TI.DUCATI1.VIDEO.DECODER" },

                    +    { MEDIA_MIMETYPE_VIDEO_AVC, "AVCDecoder" },

                    +    { MEDIA_MIMETYPE_AUDIO_VORBIS, "VorbisDecoder" },

                    +    { MEDIA_MIMETYPE_VIDEO_VP6, "OMX.TI.DUCATI1.VIDEO.DECODER" },

                    +    { MEDIA_MIMETYPE_VIDEO_VP7, "OMX.TI.DUCATI1.VIDEO.DECODER" }

                    +};

                    +

                    +//Maintain only s/w encoders till ducati encoders are integrated to SF

                    +static const CodecInfo kEncoderInfo[] = {

                    +    { MEDIA_MIMETYPE_AUDIO_AMR_NB, "AMRNBEncoder" },

                    +    { MEDIA_MIMETYPE_AUDIO_AAC, "OMX.ITTIAM.AAC.encode" },

                    +    { MEDIA_MIMETYPE_AUDIO_AAC, "AACEncoder" },

                    +    { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.TI.DUCATI1.VIDEO.MPEG4E" },

                    +    { MEDIA_MIMETYPE_VIDEO_H263, "OMX.TI.DUCATI1.VIDEO.MPEG4E" },

                    +    { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.TI.DUCATI1.VIDEO.H264E" },

                    +};

                    +#elif defined(TARGET_OMAP3)

                    +static const CodecInfo kDecoderInfo[] = {

                    +    { MEDIA_MIMETYPE_IMAGE_JPEG, "OMX.TI.JPEG.decode" },

                    +    { MEDIA_MIMETYPE_AUDIO_MPEG, "OMX.TI.MP3.decode" },

                    +    { MEDIA_MIMETYPE_AUDIO_MPEG, "OMX.PV.mp3dec" },

                    +    { MEDIA_MIMETYPE_AUDIO_AMR_NB, "OMX.TI.AMR.decode" },

                    +    { MEDIA_MIMETYPE_AUDIO_AMR_NB, "OMX.PV.amrdec" },

                    +    { MEDIA_MIMETYPE_AUDIO_AMR_WB, "OMX.TI.WBAMR.decode" },

                    +    { MEDIA_MIMETYPE_AUDIO_AMR_WB, "OMX.PV.amrdec" },

                    +    { MEDIA_MIMETYPE_AUDIO_AAC, "OMX.TI.AAC.decode" },

                    +    { MEDIA_MIMETYPE_AUDIO_AAC, "OMX.ITTIAM.AAC.decode" },

                    +    { MEDIA_MIMETYPE_AUDIO_AAC, "OMX.PV.aacdec" },

                    +    { MEDIA_MIMETYPE_AUDIO_AAC, "AACDecoder" },

                    +    { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.TI.Video.Decoder" },

                    +    { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.TI.720P.Decoder" },

                    +    { MEDIA_MIMETYPE_VIDEO_H263, "OMX.TI.Video.Decoder" },

                    +    /* 720p Video Decoder must be placed before the TI Video Decoder.

                    +       DO NOT CHANGE THIS SEQUENCE. IT WILL BREAK FLASH. */

                    +    { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.TI.720P.Decoder" },

                    +    { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.TI.Video.Decoder" },

                    +    { MEDIA_MIMETYPE_AUDIO_VORBIS, "VorbisDecoder" },

                    +    { MEDIA_MIMETYPE_VIDEO_WMV, "OMX.TI.Video.Decoder" },

                    +    { MEDIA_MIMETYPE_VIDEO_WMV, "OMX.TI.720P.Decoder" },

                    +    { MEDIA_MIMETYPE_AUDIO_WMA, "OMX.TI.WMA.decode"},

                    +    { MEDIA_MIMETYPE_AUDIO_WMA, "OMX.ITTIAM.WMA.decode"},

                    +};

                    +

                    +static const CodecInfo kEncoderInfo[] = {

                    +    { MEDIA_MIMETYPE_AUDIO_AMR_NB, "OMX.TI.AMR.encode" },

                    +    { MEDIA_MIMETYPE_AUDIO_AMR_WB, "OMX.TI.WBAMR.encode" },

                    +    { MEDIA_MIMETYPE_AUDIO_AAC, "OMX.TI.AAC.encode" },

                    +    { MEDIA_MIMETYPE_AUDIO_AAC, "OMX.ITTIAM.AAC.encode" },

                    +    { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.TI.Video.encoder" },

                    +    { MEDIA_MIMETYPE_VIDEO_MPEG4, "OMX.TI.720P.Encoder" },

                    +    { MEDIA_MIMETYPE_VIDEO_H263, "OMX.TI.Video.encoder" },

                    +    { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.TI.Video.encoder" },

                    +    { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.TI.720P.Encoder" },

                    +};

                    +#endif

                    +#else

                     static const CodecInfo kDecoderInfo[] = {

                         { MEDIA_MIMETYPE_IMAGE_JPEG, "OMX.TI.JPEG.decode" },

                         { MEDIA_MIMETYPE_AUDIO_MPEG, "OMX.Nvidia.mp3.decoder" },

                    @@ -233,6 +382,7 @@ static const CodecInfo kEncoderInfo[] = {

                         { MEDIA_MIMETYPE_VIDEO_AVC, "AVCEncoder" },

                     //    { MEDIA_MIMETYPE_VIDEO_AVC, "OMX.PV.avcenc" },

                     };

                    +#endif

                     #undef OPTIONAL

                    @@ -240,6 +390,19 @@ static const CodecInfo kEncoderInfo[] = {

                     #define CODEC_LOGV(x, ...) LOGV("[%s] "x, mComponentName, ##__VA_ARGS__)

                     #define CODEC_LOGE(x, ...) LOGE("[%s] "x, mComponentName, ##__VA_ARGS__)

                    +#ifdef OMAP_ENHANCEMENT

                    +/* This flag has to be updated according to the Memory dealer cache line

                    + * alignment value "SimpleBestFitAllocator::kMemoryAlign"

                    + * It is required to allocate correct amount of memory considering the

                    + * alignment, Otherwise alloc fails when input buffer sizes are not aligned*/

                    +#ifdef TARGET_OMAP4

                    +#define CACHELINE_BOUNDARY_MEMALIGNMENT 32

                    +#else

                    +#define CACHELINE_BOUNDARY_MEMALIGNMENT 128

                    +#endif

                    +#endif

                    +

                    +#ifndef OMAP_ENHANCEMENT

                     struct OMXCodecObserver : public BnOMXObserver {

                         OMXCodecObserver() {

                         }

                    @@ -275,6 +438,7 @@ private:

                         OMXCodecObserver(const OMXCodecObserver &);

                         OMXCodecObserver &operator=(const OMXCodecObserver &);

                     };

                    +#endif

                     static const char *GetCodec(const CodecInfo *info, size_t numInfos,

                                                 const char *mime, int index) {

                    @@ -325,6 +489,7 @@ static const char *AVCProfileToString(uint8_t profile) {

                         }

                     }

                    +#ifndef OMAP_ENHANCEMENT

                     template<class T>

                     static void InitOMXParams(T *params) {

                         params->nSize = sizeof(T);

                    @@ -333,6 +498,7 @@ static void InitOMXParams(T *params) {

                         params->nVersion.s.nRevision = 0;

                         params->nVersion.s.nStep = 0;

                     }

                    +#endif

                     static bool IsSoftwareCodec(const char *componentName) {

                         if (!strncmp("OMX.PV.", componentName, 7)) {

                    @@ -374,8 +540,12 @@ static int CompareSoftwareCodecsFirst(

                     }

                     // static

                    +#ifdef OMAP_ENHANCEMENT

                    +uint32_t OMXCodec::getComponentQuirks(const char *componentName,bool isEncoder, uint32_t flags) {

                    +#else

                     uint32_t OMXCodec::getComponentQuirks(

                             const char *componentName, bool isEncoder) {

                    +#endif

                         uint32_t quirks = 0;

                         if (!strcmp(componentName, "OMX.PV.avcdec")) {

                    @@ -392,12 +562,43 @@ uint32_t OMXCodec::getComponentQuirks(

                         if (!strcmp(componentName, "OMX.TI.MP3.decode")) {

                             quirks |= kNeedsFlushBeforeDisable;

                             quirks |= kDecoderLiesAboutNumberOfChannels;

                    +#ifdef OMAP_ENHANCEMENT

                    +        quirks |= kSupportsMultipleFramesPerInputBuffer;

                    +        quirks |= kDecoderCantRenderSmallClips;

                    +#endif

                         }

                         if (!strcmp(componentName, "OMX.TI.AAC.decode")) {

                             quirks |= kNeedsFlushBeforeDisable;

                             quirks |= kRequiresFlushCompleteEmulation;

                             quirks |= kSupportsMultipleFramesPerInputBuffer;

                         }

                    +#ifdef OMAP_ENHANCEMENT

                    +    if (!strcmp(componentName, "OMX.TI.WMA.decode")) {

                    +        quirks |= kNeedsFlushBeforeDisable;

                    +        quirks |= kRequiresFlushCompleteEmulation;

                    +    }

                    +    if (!strcmp(componentName, "OMX.ITTIAM.WMA.decode")) {

                    +       quirks |= kNeedsFlushBeforeDisable;

                    +       quirks |= kRequiresFlushCompleteEmulation;

                    +    }

                    +    if (!strcmp(componentName, "OMX.ITTIAM.WMALSL.decode")) {

                    +        quirks |= kNeedsFlushBeforeDisable;

                    +        quirks |= kRequiresFlushCompleteEmulation;

                    +    }

                    +    if (!strcmp(componentName, "OMX.ITTIAM.WMAPRO.decode")) {

                    +        quirks |= kNeedsFlushBeforeDisable;

                    +        quirks |= kRequiresFlushCompleteEmulation;

                    +    }

                    +    if (!strcmp(componentName, "OMX.ITTIAM.AAC.decode")) {

                    +

                    +        quirks |= kNeedsFlushBeforeDisable;

                    +        quirks |= kDecoderNeedsPortReconfiguration;

                    +    }

                    +    if (!strcmp(componentName, "OMX.PV.aacdec")) {

                    +        quirks |= kNeedsFlushBeforeDisable;

                    +        quirks |= kDecoderNeedsPortReconfiguration;

                    +    }

                    +#endif

                         if (!strncmp(componentName, "OMX.qcom.video.encoder.", 23)) {

                             quirks |= kRequiresLoadedToIdleAfterAllocation;

                             quirks |= kRequiresAllocateBufferOnInputPorts;

                    @@ -427,24 +628,66 @@ uint32_t OMXCodec::getComponentQuirks(

                             quirks |= kDefersOutputBufferAllocation;

                             quirks |= kDoesNotRequireMemcpyOnOutputPort;

                         }

                    +#ifdef OMAP_ENHANCEMENT

                    +    if (!strcmp(componentName, "OMX.TI.Video.Decoder") ||

                    +            !strcmp(componentName, "OMX.TI.720P.Decoder")) {

                    +        // TI Video Decoder and TI 720p Decoder must use buffers allocated

                    +        // by Overlay for output port. So, I cannot call OMX_AllocateBuffer

                    +        // on output port. I must use OMX_UseBuffer on input port to ensure

                    +        // 128 byte alignment.

                    +        quirks |= kRequiresAllocateBufferOnInputPorts;

                    +        quirks |= kInputBufferSizesAreBogus;

                    +

                    +        if( flags & kPreferThumbnailMode) {

                    +                quirks |= OMXCodec::kRequiresAllocateBufferOnOutputPorts;

                    +        }

                    +    }

                    +#ifdef TARGET_OMAP4

                    +    else if(!strcmp(componentName, "OMX.TI.DUCATI1.VIDEO.DECODER")) {

                    +        //quirks |= kRequiresAllocateBufferOnInputPorts;

                    +        quirks |= kNeedsFlushBeforeDisable;

                    +        if(flags & kPreferThumbnailMode)

                    +        {

                    +            quirks |= OMXCodec::kThumbnailMode;

                    +        }

                    +

                    +        if(flags & kPreferInterlacedOutputContent) {

                    +                quirks |= OMXCodec::kInterlacedOutputContent;

                    +        }

                    +

                    +    }

                    +#endif

                    +    else if (!strncmp(componentName, "OMX.TI.", 7) || !strncmp("OMX.ITTIAM.", componentName, 11)) {

                    +#else

                         if (!strncmp(componentName, "OMX.TI.", 7)) {

                    +#endif

                             // Apparently I must not use OMX_UseBuffer on either input or

                             // output ports on any of the TI components or quote:

                             // "(I) may have unexpected problem (sic) which can be timing related

                             //  and hard to reproduce."

                    +#if defined(OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +        if (!strncmp(componentName, "OMX.TI.DUCATI1.VIDEO.MPEG4E", strlen("OMX.TI.DUCATI1.VIDEO.MPEG4E")) ||

                    +           !strncmp(componentName, "OMX.TI.DUCATI1.VIDEO.H264E", strlen("OMX.TI.DUCATI1.VIDEO.H264E"))) {

                    +            LOGV("USING DUCATI ENCODER. isEncoder : %d",isEncoder);

                    +            quirks |= kRequiresAllocateBufferOnOutputPorts;

                    +            quirks |= kAvoidMemcopyInputRecordingFrames;

                    +        }

                    +#else

                             quirks |= kRequiresAllocateBufferOnInputPorts;

                             quirks |= kRequiresAllocateBufferOnOutputPorts;

                    -        if (!strncmp(componentName, "OMX.TI.Video.encoder", 20)) {

                    +        if (!strncmp(componentName, "OMX.TI.Video.encoder", 20) ||

                    +            !strncmp(componentName, "OMX.TI.720P.Encoder", 19)) {

                                 quirks |= kAvoidMemcopyInputRecordingFrames;

                             }

                    +#endif

                         }

                    -

                    +#ifndef OMAP_ENHANCEMENT

                         if (!strcmp(componentName, "OMX.TI.Video.Decoder")) {

                             quirks |= kInputBufferSizesAreBogus;

                         }

                    -

                    +#endif

                         if (!strncmp(componentName, "OMX.SEC.", 8) && !isEncoder) {

                             // These output buffers contain no video data, just some

                             // opaque information that allows the overlay to display their

                    @@ -497,6 +740,15 @@ void OMXCodec::findMatchingCodecs(

                             matchingCodecs->push(String8(componentName));

                         }

                    +#ifdef OMAP_ENHANCEMENT

                    +    char value[PROPERTY_VALUE_MAX];

                    +    property_get("debug.video.preferswcodec", value, "0");

                    +    if (atoi(value))

                    +    {

                    +        flags |= kPreferSoftwareCodecs;

                    +    }

                    +#endif

                    +

                         if (flags & kPreferSoftwareCodecs) {

                             matchingCodecs->sort(CompareSoftwareCodecsFirst);

                         }

                    @@ -539,9 +791,11 @@ sp<MediaSource> OMXCodec::Create(

                             }

                             LOGV("Attempting to allocate OMX node '%s'", componentName);

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +uint32_t quirks = getComponentQuirks(componentName, createEncoder, flags);

                    +#else

                             uint32_t quirks = getComponentQuirks(componentName, createEncoder);

                    -

                    +#endif

                             if (!createEncoder

                                     && (quirks & kOutputBuffersAreUnreadable)

                                     && (flags & kClientNeedsFramebuffer)) {

                    @@ -581,13 +835,135 @@ sp<MediaSource> OMXCodec::Create(

                         return NULL;

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +// static

                    +sp<MediaSource> OMXCodec::Create(

                    +        const sp<IOMX> &omx,

                    +        const sp<MetaData> &meta, bool createEncoder,

                    +        const sp<MediaSource> &source,

                    +        IOMX::node_id &nodeId,

                    +        const char *matchComponentName,

                    +        uint32_t flags) {

                    +    const char *mime;

                    +    bool success = meta->findCString(kKeyMIMEType, &mime);

                    +    CHECK(success);

                    +

                    +    Vector<String8> matchingCodecs;

                    +    findMatchingCodecs(

                    +            mime, createEncoder, matchComponentName, flags, &matchingCodecs);

                    +

                    +    if (matchingCodecs.isEmpty()) {

                    +        return NULL;

                    +    }

                    +

                    +    sp<OMXCodecObserver> observer = new OMXCodecObserver;

                    +    IOMX::node_id node = 0;

                    +

                    +    const char *componentName;

                    +    for (size_t i = 0; i < matchingCodecs.size(); ++i) {

                    +        componentName = matchingCodecs[i].string();

                    +

                    +#if BUILD_WITH_FULL_STAGEFRIGHT

                    +        sp<MediaSource> softwareCodec =

                    +            InstantiateSoftwareCodec(componentName, source);

                    +

                    +        if (softwareCodec != NULL) {

                    +            LOGV("Successfully allocated software codec '%s'", componentName);

                    +

                    +            return softwareCodec;

                    +        }

                    +#endif

                    +

                    +        LOGV("Attempting to allocate OMX node '%s'", componentName);

                    +

                    +        status_t err = omx->allocateNode(componentName, observer, &node);

                    +        if (err == OK) {

                    +            LOGV("Successfully allocated OMX node '%s'", componentName);

                    +

                    +#ifdef TARGET_OMAP4

                    +            sp<OMXCodec> codec = new OMXCodec(

                    +                    omx, node, getComponentQuirks(componentName,createEncoder,flags),

                    +                    createEncoder, mime, componentName,

                    +                    source);

                    +#else

                    +            sp<OMXCodec> codec = new OMXCodec(

                    +                    omx, node, getComponentQuirks(componentName,createEncoder),

                    +                    createEncoder, mime, componentName,

                    +                    source);

                    +#endif

                    +

                    +            observer->setCodec(codec);

                    +

                    +            nodeId = node;

                    +

                    +            err = codec->configureCodec(meta,flags);

                    +

                    +            if (err == OK) {

                    +                return codec;

                    +            }

                    +

                    +            LOGV("Failed to configure codec '%s'", componentName);

                    +        }

                    +    }

                    +

                    +    return NULL;

                    +}

                    +#endif

                    +

                     status_t OMXCodec::configureCodec(const sp<MetaData> &meta, uint32_t flags) {

                    +#if !(defined(OMAP_ENHANCEMENT) && defined (TARGET_OMAP4))

                         if (!(flags & kIgnoreCodecSpecificData)) {

                    +#endif

                             uint32_t type;

                             const void *data;

                             size_t size;

                    -        if (meta->findData(kKeyESDS, &type, &data, &size)) {

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    status_t err;

                    +

                    +    if (meta->findData(kKeyStreamSpecificData, &type, &data, &size))

                    +    {

                    +        if(!strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.DECODER")) {

                    +

                    +            if ((!strcasecmp(MEDIA_MIMETYPE_VIDEO_VP6, mMIME)) ||

                    +                (!strcasecmp(MEDIA_MIMETYPE_VIDEO_VP7, mMIME))) {

                    +

                    +                LOGD("Setting VP6/7 Params");

                    +                OMX_TI_PARAM_IVFFLAG tVP6Param;

                    +                InitOMXParams(&tVP6Param);

                    +                err = mOMX->getParameter(

                    +                        mNode, (OMX_INDEXTYPE)OMX_TI_IndexParamVideoIvfMode, &tVP6Param, sizeof(tVP6Param));

                    +

                    +                CHECK_EQ(err, OK);

                    +                tVP6Param.bIvfFlag = OMX_FALSE;

                    +

                    +                char *t = ((char *)(data));

                    +                if ((t[0] == 'D') && (t[1] == 'K') && (t[2] == 'I') && (t[3] == 'F')){

                    +                    LOGD("IVF Header Present. Size = %d. Limiting it to 32 as per spec.", size);

                    +                    size = 32;

                    +                    addCodecSpecificData(data, size);

                    +                    tVP6Param.bIvfFlag = OMX_TRUE;

                    +                }

                    +                err = mOMX->setParameter(

                    +                        mNode, (OMX_INDEXTYPE)OMX_TI_IndexParamVideoIvfMode, &tVP6Param, sizeof(tVP6Param));

                    +

                    +                OMX_TI_PARAM_PAYLOADHEADERFLAG tVP6Payloadheader;

                    +                InitOMXParams(&tVP6Payloadheader);

                    +                err = mOMX->getParameter(

                    +                        mNode, (OMX_INDEXTYPE)OMX_TI_IndexParamVideoPayloadHeaderFlag, &tVP6Payloadheader, sizeof(tVP6Payloadheader));

                    +                CHECK_EQ(err, OK);

                    +                tVP6Payloadheader.bPayloadHeaderFlag = OMX_FALSE;

                    +                err = mOMX->setParameter(

                    +                        mNode, (OMX_INDEXTYPE)OMX_TI_IndexParamVideoPayloadHeaderFlag, &tVP6Payloadheader, sizeof(tVP6Payloadheader));

                    +

                    +            }

                    +        }

                    +        else addCodecSpecificData(data, size);

                    +    }

                    +    else if (meta->findData(kKeyESDS, &type, &data, &size)) {

                    +#else

                    +    if (meta->findData(kKeyESDS, &type, &data, &size)) {

                    +#endif

                                 ESDS esds((const char *)data, size);

                                 CHECK_EQ(esds.InitCheck(), OK);

                    @@ -671,12 +1047,97 @@ status_t OMXCodec::configureCodec(const sp<MetaData> &meta, uint32_t flags) {

                                     LOGE("Profile and/or level exceed the decoder's capabilities.");

                                     return ERROR_UNSUPPORTED;

                                 }

                    +#ifdef OMAP_ENHANCEMENT

                    +            int32_t width, height;

                    +            bool success = meta->findInt32(kKeyWidth, &width);

                    +            success = success && meta->findInt32(kKeyHeight, &height);

                    +            CHECK(success);

                    +            if (!strcmp(mComponentName, "OMX.TI.720P.Decoder")

                    +                && (profile == kAVCProfileBaseline && level <= 39)

                    +                && (width*height <= MAX_RESOLUTION)

                    +                && (width <= MAX_RESOLUTION_WIDTH && height <= MAX_RESOLUTION_HEIGHT ))

                    +            {

                    +                // Though this decoder can handle this profile/level,

                    +                // we prefer to use "OMX.TI.Video.Decoder" for

                    +                // Baseline Profile with level <=39 and sub 720p

                    +                return ERROR_UNSUPPORTED;

                    +            }

                    +#endif

                             }

                    +#ifdef OMAP_ENHANCEMENT

                    +    else if (meta->findData(kKeyHdr, &type, &data, &size)) {

                    +        CODEC_LOGV("Codec specific information of size %d", size);

                    +        addCodecSpecificData(data, size);

                         }

                    +    if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_WMV, mMIME)) {

                    +        bool success = meta->findData(kKeyHdr, &type, &data, &size);

                    +        const uint8_t *ptr = (const uint8_t *)data;

                    +        CHECK(success);

                    +

                    +        OMX_U32 width = (((OMX_U32)ptr[18] << 24) | ((OMX_U32)ptr[17] << 16)

                    +                           | ((OMX_U32)ptr[16] << 8) | (OMX_U32)ptr[15]);

                    +        OMX_U32 height = (((OMX_U32)ptr[22] << 24) | ((OMX_U32)ptr[21] << 16)

                    +                           | ((OMX_U32)ptr[20] << 8) | (OMX_U32)ptr[19]);

                    +

                    +        CODEC_LOGV("Height and width = %u %u\n", height, width);

                    +

                    +        // MAX_RESOLUTION is used to take the decision between TI and Ittiam WMV codec.

                    +        if (!strcmp(mComponentName, "OMX.TI.Video.Decoder") &&

                    +            (width*height > MAX_RESOLUTION)) {

                    +

                    +            // need OMX.TI.720P.Decoder

                    +            return ERROR_UNSUPPORTED;

                    +        }

                    +        if(!strcmp(mComponentName, "OMX.TI.720P.Decoder")) {

                    +            OMX_U32 NewCompression = MAKEFOURCC_WMC((OMX_U8)ptr[27], (OMX_U8)ptr[28],

                    +                                                    (OMX_U8)ptr[29], (OMX_U8)ptr[30]);

                    +            OMX_U32 StreamType;

                    +            OMX_PARAM_WMVFILETYPE WMVFileType;

                    +            InitOMXParams(&WMVFileType);

                    +

                    +            if (NewCompression == FOURCC_WMV3) {

                    +                CODEC_LOGV("VIDDEC_WMV_RCVSTREAM\n");

                    +                StreamType = VIDDEC_WMV_RCVSTREAM;

                    +            } else if (NewCompression == FOURCC_WVC1) {

                    +                CODEC_LOGV("VIDDEC_WMV_ELEMSTREAM\n");

                    +                StreamType = VIDDEC_WMV_ELEMSTREAM;

                    +            } else {

                    +                CODEC_LOGI("ERROR...  PROFILE NOT KNOWN ASSUMED TO BE VIDDEC_WMV_RCVSTREAM\n");

                    +                StreamType = VIDDEC_WMV_RCVSTREAM;

                    +            }

                    +            WMVFileType.nWmvFileType = StreamType;

                    +

                    +            status_t err = mOMX->setParameter(mNode,

                    +                                              (OMX_INDEXTYPE)VideoDecodeCustomParamWMVFileType,

                    +                                              &WMVFileType, sizeof(WMVFileType));

                    +            if (err != OMX_ErrorNone) {

                    +                return err;

                    +            }

                    +        }

                    +    }

                    +#endif

                    +

                    +#if !(defined(OMAP_ENHANCEMENT) && defined (TARGET_OMAP4))

                    +    }

                    +#endif

                    +

                         int32_t bitRate = 0;

                         if (mIsEncoder) {

                             CHECK(meta->findInt32(kKeyBitRate, &bitRate));

                    +

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP3)

                    +        if (!strcmp(mComponentName, "OMX.TI.Video.encoder")) {

                    +            int32_t width, height;

                    +            bool success = meta->findInt32(kKeyWidth, &width);

                    +            success = success && meta->findInt32(kKeyHeight, &height);

                    +            CHECK(success);

                    +            if (width*height > MAX_RESOLUTION) {

                    +                // need OMX.TI.720P.Encoder

                    +                return ERROR_UNSUPPORTED;

                    +            }

                    +        }

                    +#endif

                         }

                         if (!strcasecmp(MEDIA_MIMETYPE_AUDIO_AMR_NB, mMIME)) {

                             setAMRFormat(false /* isWAMR */, bitRate);

                    @@ -692,6 +1153,28 @@ status_t OMXCodec::configureCodec(const sp<MetaData> &meta, uint32_t flags) {

                     #ifndef DONT_SET_AUDIO_AAC_FORMAT

                             setAACFormat(numChannels, sampleRate, bitRate);

                     #endif

                    +#ifdef OMAP_ENHANCEMENT

                    +        // Configure TI OMX component to FrameMode for AAC-ADTS

                    +        if (!strcmp(mComponentName, "OMX.TI.AAC.decode")) {

                    +            OMX_INDEXTYPE index;

                    +

                    +            CODEC_LOGV("OMXCodec::configureCodec() TI AAC - Configure Component to FrameMode");

                    +

                    +            // Get Extension Index from Component

                    +            status_t err = mOMX->getExtensionIndex(mNode, "OMX.TI.index.config.AacDecFrameModeInfo", &index);

                    +            if (err != OK) {

                    +                CODEC_LOGV("OMXCodec::configureCodec() TI AAC - Problem getting ExtensionIndex - Use SteamMode");

                    +            }

                    +            else {

                    +                OMX_U16 framemode = 1;

                    +                // Set FrameMode for ADTS streams

                    +                err = mOMX->setConfig(mNode, index, &framemode, sizeof(framemode));

                    +                if (err != OK) {

                    +                    CODEC_LOGV("OMXCodec::configureCodec() TI AAC - Problem configuring FrameMode - Use SteamMode");

                    +                }

                    +            }

                    +        }

                    +#endif

                         }

                         if (!strncasecmp(mMIME, "video/", 6)) {

                    @@ -703,6 +1186,142 @@ status_t OMXCodec::configureCodec(const sp<MetaData> &meta, uint32_t flags) {

                                 bool success = meta->findInt32(kKeyWidth, &width);

                                 success = success && meta->findInt32(kKeyHeight, &height);

                                 CHECK(success);

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +

                    +            /* Update proper Profile, Level, No. of Reference frames.

                    +               This will aid in less (tiler) memory utilization by ducati side */

                    +            if(!strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.DECODER")) {

                    +                /* save video FPS */

                    +                if (!(meta->findInt32(kKeyVideoFPS, &mVideoFPS))) {

                    +                    mVideoFPS = 30; //default value in case of FPS data not found

                    +                }

                    +

                    +                int32_t vprofile,vlevel,vinterlaced,vnumrefframes;

                    +

                    +                if ((!strcasecmp(MEDIA_MIMETYPE_VIDEO_AVC, mMIME)) &&

                    +                        meta->findInt32(kKeyVideoProfile, &vprofile) &&

                    +                        meta->findInt32(kKeyVideoLevel, &vlevel) &&

                    +                        meta->findInt32(kKeyVideoInterlaced, &vinterlaced) &&

                    +                        meta->findInt32(kKeyNumRefFrames, &vnumrefframes))

                    +                {

                    +

                    +                    OMX_VIDEO_PARAM_AVCTYPE h264type;

                    +                    InitOMXParams(&h264type);

                    +                    h264type.nPortIndex = kPortIndexInput;

                    +

                    +                    status_t err = mOMX->getParameter(

                    +                            mNode, OMX_IndexParamVideoAvc, &h264type, sizeof(h264type));

                    +                    CHECK_EQ(err, OK);

                    +

                    +                    //h264type.nBFrames = 0; //check if requred

                    +

                    +

                    +                    /* Update profile from uint32_t type */

                    +                    switch(vprofile)

                    +                    {

                    +                        case kAVCProfileBaseline :

                    +                                    h264type.eProfile = OMX_VIDEO_AVCProfileBaseline;

                    +                                    break;

                    +                        case kAVCProfileMain :

                    +                                    h264type.eProfile = OMX_VIDEO_AVCProfileMain;

                    +                                    break;

                    +                        case kAVCProfileExtended :

                    +                                    h264type.eProfile = OMX_VIDEO_AVCProfileExtended;

                    +                                    break;

                    +                        case kAVCProfileHigh :

                    +                                    h264type.eProfile = OMX_VIDEO_AVCProfileHigh;

                    +                                    break;

                    +

                    +                        case kAVCProfileHigh10 :

                    +                        case kAVCProfileHigh422 :

                    +                        case kAVCProfileHigh444 :

                    +                        default:

                    +                                    //Unsupported profiles by OMX.TI.DUCATI1.VIDEO.DECODER

                    +                                    LOGE("profile code 0x%x %d not supported", vprofile,vprofile);

                    +                                    CHECK_EQ(0,1);

                    +                                    return UNKNOWN_ERROR;

                    +                    }

                    +

                    +

                    +                    switch(vlevel)

                    +                    {

                    +

                    +                        case 9 :

                    +                                    h264type.eLevel = OMX_VIDEO_AVCLevel1b;

                    +                                    break;

                    +                        case 10 :

                    +                                    h264type.eLevel = OMX_VIDEO_AVCLevel1;

                    +                                    break;

                    +                        case 11 :

                    +                                    h264type.eLevel = OMX_VIDEO_AVCLevel11;

                    +                                    break;

                    +                        case 12 :

                    +                                    h264type.eLevel = OMX_VIDEO_AVCLevel12;

                    +                                    break;

                    +                        case 13 :

                    +                                    h264type.eLevel = OMX_VIDEO_AVCLevel13;

                    +                                    break;

                    +                        case 20 :

                    +                                    h264type.eLevel = OMX_VIDEO_AVCLevel2;

                    +                                    break;

                    +                        case 21 :

                    +                                    h264type.eLevel = OMX_VIDEO_AVCLevel21;

                    +                                    break;

                    +                        case 22 :

                    +                                    h264type.eLevel = OMX_VIDEO_AVCLevel22;

                    +                                    break;

                    +                        case 30 :

                    +                                    h264type.eLevel = OMX_VIDEO_AVCLevel3;

                    +                                    break;

                    +                        case 31 :

                    +                                    h264type.eLevel = OMX_VIDEO_AVCLevel31;

                    +                                    break;

                    +                        case 32 :

                    +                                    h264type.eLevel = OMX_VIDEO_AVCLevel32;

                    +                                    break;

                    +

                    +                        case 40 :

                    +                                    h264type.eLevel = OMX_VIDEO_AVCLevel4;

                    +                                    break;

                    +

                    +                        case 41 :

                    +                                    h264type.eLevel = OMX_VIDEO_AVCLevel41;

                    +                                    break;

                    +

                    +                        case 42 :

                    +                                    h264type.eLevel = OMX_VIDEO_AVCLevel42;

                    +                                    break;

                    +

                    +                        case 50 :

                    +                                    h264type.eLevel = OMX_VIDEO_AVCLevel5;

                    +                                    break;

                    +

                    +                        case 51 :

                    +                                    h264type.eLevel = OMX_VIDEO_AVCLevel51;

                    +                                    break;

                    +

                    +                        default:

                    +                                    //Unsupported level value

                    +                                    LOGE("profile code 0x%x %d not supported", vlevel,vlevel);

                    +                                    CHECK_EQ(0,1);

                    +                                    return UNKNOWN_ERROR;

                    +                    }

                    +

                    +                    h264type.nRefFrames = vnumrefframes;

                    +

                    +                    err = mOMX->setParameter(

                    +                            mNode, OMX_IndexParamVideoAvc, &h264type, sizeof(h264type));

                    +                    CHECK_EQ(err, OK);

                    +

                    +                    /* Cross check from component */

                    +                    err = mOMX->getParameter(

                    +                            mNode, OMX_IndexParamVideoAvc, &h264type, sizeof(h264type));

                    +

                    +                    LOGD("Updated. H264 Component profile %d level %d NRefFrames %d", h264type.eProfile,h264type.eLevel, (int)h264type.nRefFrames);

                    +                }

                    +            }

                    +#endif

                                 status_t err = setVideoOutputFormat(

                                         mMIME, width, height);

                    @@ -737,6 +1356,14 @@ status_t OMXCodec::configureCodec(const sp<MetaData> &meta, uint32_t flags) {

                         int32_t maxInputSize;

                         if (meta->findInt32(kKeyMaxInputSize, &maxInputSize)) {

                    +#ifdef OMAP_ENHANCEMENT

                    +        if (!strcmp(mComponentName, "OMX.TI.Video.Decoder") || !strcmp(mComponentName, "OMX.TI.720P.Decoder")) {

                    +            // We need to allocate at least twice the "maxInputSize"

                    +            // to get enough room for internal OMX buffer handling.

                    +            maxInputSize += maxInputSize;

                    +            CODEC_LOGV("Resize maxInputSize*2, maxInputSize=%d", maxInputSize);

                    +        }

                    +#endif

                             setMinBufferSize(kPortIndexInput, (OMX_U32)maxInputSize);

                         }

                    @@ -775,6 +1402,17 @@ status_t OMXCodec::configureCodec(const sp<MetaData> &meta, uint32_t flags) {

                             mQuirks &= ~kOutputBuffersAreUnreadable;

                         }

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    mNSecsToWait = 5000000000; // 5 seconds

                    +    const char *flash_fp_usecase;

                    +    const char *flash_em_usecase;

                    +    if ((meta->findCString('fpfl', &flash_fp_usecase)) ||

                    +        (meta->findCString('fpem', &flash_em_usecase))) {

                    +        LOGD("\n\n\n Executing a flash usecase \n\n\n");

                    +        mNSecsToWait = 0;

                    +    }

                    +#endif

                    +

                         return OK;

                     }

                    @@ -792,6 +1430,17 @@ void OMXCodec::setMinBufferSize(OMX_U32 portIndex, OMX_U32 size) {

                             def.nBufferSize = size;

                         }

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    /* Aligning the buffer size as observed memory failures in allocateBuffersOnPort

                    +     * for input port incase buffer sizes are not Cache line boundary aligned.

                    +     * Actually the Memory Dealer allocates a large chunk for the Total buffer size.

                    +     * While requesting individual buffers, it provides chunks (offset) from the large

                    +     * memory. During this, it provides address based on Cache line boundary. Hence

                    +     * there would not be sufficient memory for the last chunk and it fails */

                    +    def.nBufferSize = ((def.nBufferSize + CACHELINE_BOUNDARY_MEMALIGNMENT - 1) &

                    +                        ~(CACHELINE_BOUNDARY_MEMALIGNMENT - 1));

                    +#endif

                    +

                         err = mOMX->setParameter(

                                 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));

                         CHECK_EQ(err, OK);

                    @@ -839,7 +1488,8 @@ status_t OMXCodec::setVideoPortFormatType(

                                  index, format.eCompressionFormat, format.eColorFormat);

                     #endif

                    -        if (!strcmp("OMX.TI.Video.encoder", mComponentName)) {

                    +        if (!strcmp("OMX.TI.Video.encoder", mComponentName) ||

                    +            !strcmp("OMX.TI.720P.Encoder", mComponentName)) {

                                 if (portIndex == kPortIndexInput

                                         && colorFormat == format.eColorFormat) {

                                     // eCompressionFormat does not seem right.

                    @@ -854,6 +1504,20 @@ status_t OMXCodec::setVideoPortFormatType(

                                 }

                             }

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +        if (!strcmp("OMX.TI.DUCATI1.VIDEO.DECODER", mComponentName)) {

                    +            if ( (compressionFormat == OMX_VIDEO_CodingH263) &&

                    +                 (format.eCompressionFormat != compressionFormat) ) {

                    +                // Ducati Decoder returns MPEG4 as default compression type.

                    +                // Update H263 compression type

                    +                format.eCompressionFormat=compressionFormat;

                    +                found = true;

                    +                break;

                    +            }

                    +        format.eColorFormat = colorFormat; //HACK. Should be removed in 1.20 ducati release

                    +        }

                    +#endif

                    +

                             if (format.eCompressionFormat == compressionFormat

                                 && format.eColorFormat == colorFormat) {

                                 found = true;

                    @@ -886,6 +1550,11 @@ static size_t getFrameSize(

                             case OMX_COLOR_FormatYUV420SemiPlanar:

                                 return (width * height * 3) / 2;

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +        case OMX_COLOR_FormatYUV420PackedSemiPlanar:

                    +            return (4096 * height *3)/2;

                    +#endif

                    +

                             default:

                                 CHECK(!"Should not be here. Unsupported color format.");

                                 break;

                    @@ -902,7 +1571,8 @@ status_t OMXCodec::findTargetColorFormat(

                         if (meta->findInt32(kKeyColorFormat, &targetColorFormat)) {

                             *colorFormat = (OMX_COLOR_FORMATTYPE) targetColorFormat;

                         } else {

                    -        if (!strcasecmp("OMX.TI.Video.encoder", mComponentName)) {

                    +        if (!strcasecmp("OMX.TI.Video.encoder", mComponentName) ||

                    +            !strcasecmp("OMX.TI.720P.Encoder", mComponentName)) {

                                 *colorFormat = OMX_COLOR_FormatYCbYCr;

                             }

                         }

                    @@ -956,12 +1626,20 @@ void OMXCodec::setVideoInputFormat(

                             const char *mime, const sp<MetaData>& meta) {

                         int32_t width, height, frameRate, bitRate, stride, sliceHeight;

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +    int32_t paddedWidth, paddedHeight;

                    +#endif

                         bool success = meta->findInt32(kKeyWidth, &width);

                         success = success && meta->findInt32(kKeyHeight, &height);

                         success = success && meta->findInt32(kKeySampleRate, &frameRate);

                         success = success && meta->findInt32(kKeyBitRate, &bitRate);

                         success = success && meta->findInt32(kKeyStride, &stride);

                         success = success && meta->findInt32(kKeySliceHeight, &sliceHeight);

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +    success = success && meta->findInt32(kKeyPaddedWidth, &paddedWidth);

                    +    success = success && meta->findInt32(kKeyPaddedHeight, &paddedHeight);

                    +#endif

                    +

                         CHECK(success);

                         CHECK(stride != 0);

                    @@ -972,6 +1650,12 @@ void OMXCodec::setVideoInputFormat(

                             compressionFormat = OMX_VIDEO_CodingMPEG4;

                         } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_H263, mime)) {

                             compressionFormat = OMX_VIDEO_CodingH263;

                    +#ifdef OMAP_ENHANCEMENT

                    +    }

                    +    else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_WMV, mime))

                    +    {

                    +        compressionFormat = OMX_VIDEO_CodingWMV;

                    +#endif

                         } else {

                             LOGE("Not a supported video mime type: %s", mime);

                             CHECK(!"Should not be here. Not a supported video mime type.");

                    @@ -996,15 +1680,37 @@ void OMXCodec::setVideoInputFormat(

                                 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));

                         CHECK_EQ(err, OK);

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +    def.nBufferSize = getFrameSize(colorFormat,

                    +            stride > 0? stride: -stride, paddedHeight);

                    +#else

                         def.nBufferSize = getFrameSize(colorFormat,

                                 stride > 0? stride: -stride, sliceHeight);

                    +#endif

                         CHECK_EQ(def.eDomain, OMX_PortDomainVideo);

                         video_def->nFrameWidth = width;

                         video_def->nFrameHeight = height;

                         video_def->nStride = stride;

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +    if( !strcmp(mComponentName,"OMX.TI.DUCATI1.VIDEO.H264E")

                    +        || !strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.MPEG4E")){

                    +        video_def->nStride = 4096; // TI 2D-Buffer specific Hardcoding

                    +    }

                    +

                    +    def.nBufferCountActual = INPUT_BUFFER_COUNT;

                    +    if(!strcmp(mComponentName,"OMX.TI.DUCATI1.VIDEO.H264E"))

                    +    {

                    +#ifdef SUPPORT_B_FRAMES

                    +        def.nBufferCountActual = OMX_NUM_B_FRAMES + 1;;

                    +#else

                    +        def.nBufferCountActual = 2;

                    +#endif

                    +    }

                    +#else

                         video_def->nSliceHeight = sliceHeight;

                    +#endif

                         video_def->xFramerate = (frameRate << 16);  // Q16 format

                         video_def->eCompressionFormat = OMX_VIDEO_CodingUnused;

                         video_def->eColorFormat = colorFormat;

                    @@ -1037,10 +1743,40 @@ void OMXCodec::setVideoInputFormat(

                             def.nBufferSize = ((def.nBufferSize * 3) >> 1);

                         }

                    +#ifdef TARGET_OMAP4

                    +    def.nBufferCountActual = OUTPUT_BUFFER_COUNT;

                    +#endif

                         err = mOMX->setParameter(

                                 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));

                         CHECK_EQ(err, OK);

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +    if( !strcmp(mComponentName,"OMX.TI.DUCATI1.VIDEO.H264E")

                    +        || !strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.MPEG4E")){

                    +

                    +        //OMX_TI_IndexParam2DBufferAllocDimension

                    +        OMX_CONFIG_RECTTYPE tFrameDim;

                    +        tFrameDim.nPortIndex = kPortIndexInput;

                    +        tFrameDim.nWidth = paddedWidth;

                    +        tFrameDim.nHeight = paddedHeight;

                    +        InitOMXParams(&tFrameDim);

                    +

                    +        err = mOMX->setParameter( mNode, (OMX_INDEXTYPE)OMX_TI_IndexParam2DBufferAllocDimension, &tFrameDim, sizeof(tFrameDim));

                    +            CHECK_EQ(err, OK);

                    +

                    +        //OMX_TI_IndexParamBufferPreAnnouncement

                    +        OMX_TI_PARAM_BUFFERPREANNOUNCE PreAnnouncement;

                    +        InitOMXParams(&PreAnnouncement);

                    +        PreAnnouncement.nPortIndex = kPortIndexInput;

                    +        err = mOMX->getParameter( mNode, (OMX_INDEXTYPE)OMX_TI_IndexParamBufferPreAnnouncement, &PreAnnouncement, sizeof(PreAnnouncement));

                    +        CHECK_EQ(err, OK);

                    +

                    +        PreAnnouncement.bEnabled = OMX_FALSE;

                    +        err = mOMX->setParameter( mNode, (OMX_INDEXTYPE)OMX_TI_IndexParamBufferPreAnnouncement, &PreAnnouncement,sizeof(PreAnnouncement));

                    +        CHECK_EQ(err, OK);

                    +    }

                    +#endif

                    +

                         /////////////////// Codec-specific ////////////////////////

                         switch (compressionFormat) {

                             case OMX_VIDEO_CodingMPEG4:

                    @@ -1090,8 +1826,13 @@ status_t OMXCodec::setupErrorCorrectionParameters() {

                         }

                         errorCorrectionType.bEnableHEC = OMX_FALSE;

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +    errorCorrectionType.bEnableResync = OMX_FALSE;

                    +    errorCorrectionType.nResynchMarkerSpacing = 0;

                    +#else

                         errorCorrectionType.bEnableResync = OMX_TRUE;

                         errorCorrectionType.nResynchMarkerSpacing = 256;

                    +#endif

                         errorCorrectionType.bEnableDataPartitioning = OMX_FALSE;

                         errorCorrectionType.bEnableRVLC = OMX_FALSE;

                    @@ -1116,7 +1857,19 @@ status_t OMXCodec::setupBitRate(int32_t bitRate) {

                                 &bitrateType, sizeof(bitrateType));

                         CHECK_EQ(err, OK);

                    +#if defined (TARGET_OMAP4) && defined (OMAP_ENHANCEMENT)

                    +    if(!strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.H264E"))

                    +    {

                    +        bitrateType.eControlRate = OMX_Video_ControlRateVariable;

                    +    }

                    +    else if(!strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.MPEG4E"))

                    +    {

                    +        bitrateType.eControlRate = OMX_Video_ControlRateVariable;

                    +    }

                    +#else

                         bitrateType.eControlRate = OMX_Video_ControlRateVariable;

                    +#endif

                    +

                         bitrateType.nTargetBitrate = bitRate;

                         err = mOMX->setParameter(

                    @@ -1126,6 +1879,120 @@ status_t OMXCodec::setupBitRate(int32_t bitRate) {

                         return OK;

                     }

                    +#if defined (TARGET_OMAP4) && defined (OMAP_ENHANCEMENT)

                    +status_t OMXCodec::setupEncoderPresetParams(int32_t isS3DEnabled) {

                    +    OMX_VIDEO_PARAM_ENCODER_PRESETTYPE EncoderPreset;

                    +    status_t Err = OK;

                    +

                    +    /*Encoder Preset settings*/

                    +    InitOMXParams(&EncoderPreset);

                    +    EncoderPreset.nPortIndex = kPortIndexOutput;

                    +    Err = mOMX->getParameter(mNode, (OMX_INDEXTYPE)OMX_TI_IndexParamVideoEncoderPreset, &EncoderPreset,sizeof(EncoderPreset));

                    +    CHECK_EQ(Err, OK);

                    +

                    +    if(!strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.H264E"))

                    +    {

                    +//#ifdef FOURMV_ENABLED

                    +        if(isS3DEnabled)

                    +            EncoderPreset.eEncodingModePreset = OMX_Video_Enc_User_Defined;

                    +        else

                    +            EncoderPreset.eEncodingModePreset = OMX_Video_Enc_Med_Speed_High_Quality;

                    +

                    +        EncoderPreset.eRateControlPreset= OMX_Video_RC_Storage ; //mpeg4VencClient->encoderPreset.eRateControlPreset;  // 4

                    +//#endif

                    +    }

                    +    else if(!strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.MPEG4E"))

                    +    {

                    +        EncoderPreset.eEncodingModePreset = OMX_Video_Enc_User_Defined; // mpeg4VencClient->encoderPreset.eEncodingModePreset; // 2

                    +        EncoderPreset.eRateControlPreset= OMX_Video_RC_Storage ; //mpeg4VencClient->encoderPreset.eRateControlPreset;  // 4

                    +    }

                    +

                    +    Err = mOMX->setParameter(mNode, (OMX_INDEXTYPE)OMX_TI_IndexParamVideoEncoderPreset, &EncoderPreset,sizeof(EncoderPreset));

                    +    CHECK_EQ(Err, OK);

                    +

                    +    return Err;

                    +}

                    +#endif

                    +

                    +#if defined (TARGET_OMAP4) && defined (OMAP_ENHANCEMENT)

                    +

                    +static int32_t getFrameLayout(const char* frameLayout)

                    +{

                    +    if (!strcmp(frameLayout, TICameraParameters::S3D_TB_FULL)) {

                    +       return OMX_TI_Video_FRAMEPACK_TOP_BOTTOM;

                    +    }

                    +

                    +    if (!strcmp(frameLayout, TICameraParameters::S3D_SS_FULL)) {

                    +        return OMX_TI_Video_FRAMEPACK_SIDE_BY_SIDE;

                    +    }

                    +    if (!strcmp(frameLayout, TICameraParameters::S3D_TB_SUBSAMPLED)) {

                    +        return OMX_TI_Video_FRAMEPACK_TOP_BOTTOM;

                    +    }

                    +

                    +    if (!strcmp(frameLayout,TICameraParameters::S3D_SS_SUBSAMPLED)) {

                    +       return OMX_TI_Video_FRAMEPACK_SIDE_BY_SIDE;

                    +    }

                    +

                    +    LOGE("Unsupported frame layout (%s)", frameLayout);

                    +

                    +    CHECK_EQ(0, "Unsupported frame layout");

                    +    return OMX_TI_Video_FRAMEPACK_TOP_BOTTOM;

                    +}

                    +

                    +status_t OMXCodec::setupEncoderFrameDataContentParams(const sp<MetaData>& meta) {

                    +    OMX_TI_VIDEO_PARAM_FRAMEDATACONTENTTYPE FrameDataType;

                    +    status_t Err = OK;

                    +    int32_t seiEncodingType;

                    +    const char *frameLayout;

                    +

                    +    bool success = meta->findInt32(kKeySEIEncodingType, &seiEncodingType);

                    +    CHECK(success);

                    +

                    +    InitOMXParams(&FrameDataType);

                    +    FrameDataType.nPortIndex = kPortIndexInput;

                    +    Err = mOMX->getParameter(mNode, (OMX_INDEXTYPE)OMX_TI_IndexParamVideoFrameDataContentSettings, &FrameDataType,sizeof(FrameDataType));

                    +    CHECK_EQ(Err, OK);

                    +

                    +    FrameDataType.eContentType = (OMX_TI_VIDEO_FRAMECONTENTTYPE) seiEncodingType;

                    +    Err = mOMX->setParameter(mNode, (OMX_INDEXTYPE)OMX_TI_IndexParamVideoFrameDataContentSettings, &FrameDataType,sizeof(FrameDataType));

                    +    CHECK_EQ(Err, OK);

                    +

                    +    if(OMX_TI_Video_AVC_2010_StereoFramePackingType == seiEncodingType) {

                    +        success = meta->findCString(kKeyFrameLayout, &frameLayout);

                    +        CHECK(success);

                    +

                    +        OMX_TI_VIDEO_PARAM_AVCENC_FRAMEPACKINGINFO2010 SettingsSEI2010;

                    +        InitOMXParams(&SettingsSEI2010);

                    +        SettingsSEI2010.nPortIndex = kPortIndexInput;

                    +        Err = mOMX->getParameter(mNode, (OMX_INDEXTYPE)OMX_TI_IndexParamStereoFramePacking2010Settings, &SettingsSEI2010,sizeof(SettingsSEI2010));

                    +        CHECK_EQ(Err, OK);

                    +

                    +        SettingsSEI2010.eFramePackingType = (OMX_TI_VIDEO_AVCSTEREO_FRAMEPACKTYPE) getFrameLayout(frameLayout);

                    +        SettingsSEI2010.nFrame0PositionX = 0;

                    +        SettingsSEI2010.nFrame0PositionY = 0;

                    +        SettingsSEI2010.nFrame1PositionX = 0;

                    +        SettingsSEI2010.nFrame1PositionY = 0;

                    +        Err = mOMX->setParameter(mNode, (OMX_INDEXTYPE)OMX_TI_IndexParamStereoFramePacking2010Settings, &SettingsSEI2010,sizeof(SettingsSEI2010));

                    +        CHECK_EQ(Err, OK);

                    +    }

                    +    else if(OMX_TI_Video_AVC_2004_StereoInfoType == seiEncodingType)

                    +    {

                    +        OMX_TI_VIDEO_PARAM_AVCENC_STEREOINFO2004 SettingsSEI2004;

                    +        InitOMXParams(&SettingsSEI2004);

                    +        SettingsSEI2004.nPortIndex = kPortIndexInput;

                    +        Err = mOMX->getParameter(mNode, (OMX_INDEXTYPE)OMX_TI_IndexParamStereoInfo2004Settings, &SettingsSEI2004,sizeof(SettingsSEI2004));

                    +        CHECK_EQ(Err, OK);

                    +

                    +        SettingsSEI2004.btopFieldIsLeftViewFlag = OMX_TRUE;

                    +        SettingsSEI2004.bViewSelfContainedFlag = OMX_FALSE;

                    +        Err = mOMX->setParameter(mNode, (OMX_INDEXTYPE)OMX_TI_IndexParamStereoInfo2004Settings, &SettingsSEI2004,sizeof(SettingsSEI2004));

                    +        CHECK_EQ(Err, OK);

                    +    }

                    +

                    +    return Err;

                    +}

                    +#endif

                    +

                     status_t OMXCodec::getVideoProfileLevel(

                             const sp<MetaData>& meta,

                             const CodecProfileLevel& defaultProfileLevel,

                    @@ -1214,6 +2081,11 @@ status_t OMXCodec::setupH263EncoderParameters(const sp<MetaData>& meta) {

                         h263type.nPictureHeaderRepetition = 0;

                         h263type.nGOBHeaderInterval = 0;

                    +#if defined (TARGET_OMAP4) && defined (OMAP_ENHANCEMENT)

                    +    h263type.eProfile = OMX_VIDEO_H263ProfileBaseline;

                    +    h263type.eLevel =  OMX_VIDEO_H263Level70;

                    +#endif

                    +

                         err = mOMX->setParameter(

                                 mNode, OMX_IndexParamVideoH263, &h263type, sizeof(h263type));

                         if (!(mQuirks & kCanNotSetVideoParameters)) {

                    @@ -1222,6 +2094,45 @@ status_t OMXCodec::setupH263EncoderParameters(const sp<MetaData>& meta) {

                         CHECK_EQ(setupBitRate(bitRate), OK);

                         CHECK_EQ(setupErrorCorrectionParameters(), OK);

                    +#if defined (TARGET_OMAP4) && defined (OMAP_ENHANCEMENT)

                    +    CHECK_EQ(setupEncoderPresetParams(false), OK);

                    +

                    +     //OMX_VIDEO_PARAM_MOTIONVECTORTYPE Settings

                    +    OMX_VIDEO_PARAM_MOTIONVECTORTYPE MotionVector;

                    +    OMX_VIDEO_PARAM_INTRAREFRESHTYPE RefreshParam;

                    +    InitOMXParams(&MotionVector);

                    +    MotionVector.nPortIndex = kPortIndexOutput;

                    +

                    +    err = mOMX->getParameter(

                    +            mNode, OMX_IndexParamVideoMotionVector, &MotionVector,sizeof(MotionVector));

                    +

                    +    MotionVector.nPortIndex = kPortIndexOutput;

                    +

                    +    // extra parameters - hardcoded

                    +    MotionVector.sXSearchRange = 16;

                    +    MotionVector.sYSearchRange = 16;

                    +    MotionVector.bFourMV =  OMX_FALSE;

                    +    MotionVector.eAccuracy =  OMX_Video_MotionVectorHalfPel ;

                    +    MotionVector.bUnrestrictedMVs = OMX_TRUE;

                    +

                    +    err = mOMX->setParameter(

                    +            mNode, OMX_IndexParamVideoMotionVector, &MotionVector,sizeof(MotionVector));

                    +

                    +    //OMX_VIDEO_PARAM_INTRAREFRESHTYPE Settings

                    +     InitOMXParams(&RefreshParam);

                    +    RefreshParam.nPortIndex = kPortIndexOutput;

                    +

                    +    err = mOMX->getParameter(

                    +            mNode, OMX_IndexParamVideoIntraRefresh, &RefreshParam,sizeof(RefreshParam));

                    +

                    +    // extra parameters - hardcoded based on PV defaults

                    +    RefreshParam.nPortIndex = kPortIndexOutput;

                    +    RefreshParam.eRefreshMode = OMX_VIDEO_IntraRefreshBoth;

                    +    //RefreshParam.nCirMBs = 0;

                    +

                    +    err = mOMX->setParameter(mNode, OMX_IndexParamVideoIntraRefresh, &RefreshParam,sizeof(RefreshParam));

                    +#endif

                    +

                         return OK;

                     }

                    @@ -1247,7 +2158,12 @@ status_t OMXCodec::setupMPEG4EncoderParameters(const sp<MetaData>& meta) {

                         mpeg4type.nAllowedPictureTypes =

                             OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +    mpeg4type.nPFrames = setPFramesSpacing(iFramesInterval, frameRate) -1;

                    +#else

                         mpeg4type.nPFrames = setPFramesSpacing(iFramesInterval, frameRate);

                    +#endif

                    +

                         if (mpeg4type.nPFrames == 0) {

                             mpeg4type.nAllowedPictureTypes = OMX_VIDEO_PictureTypeI;

                         }

                    @@ -1255,6 +2171,20 @@ status_t OMXCodec::setupMPEG4EncoderParameters(const sp<MetaData>& meta) {

                         mpeg4type.nIDCVLCThreshold = 0;

                         mpeg4type.bACPred = OMX_TRUE;

                         mpeg4type.nMaxPacketSize = 256;

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +    int32_t width, height;

                    +    success = success && meta->findInt32(kKeyWidth, &width);

                    +    success = success && meta->findInt32(kKeyHeight, &height);

                    +    // In order to have normal amount of resync markers(and packets) in the encoded stream,

                    +    // we need set this value to 4096, this will reduce the number of bits used for marking

                    +    // seperate packets in the stream and allow us to use these bits for other purposes.

                    +    if((width >= 640) || (height >= 480)) {

                    +    // To improve performance

                    +        if( (frameRate > 15) && (bitRate > 2000000)) {

                    +            mpeg4type.bACPred = OMX_FALSE;

                    +        }

                    +    }

                    +#endif

                         mpeg4type.nTimeIncRes = 1000;

                         mpeg4type.nHeaderExtension = 0;

                         mpeg4type.bReversibleVLC = OMX_FALSE;

                    @@ -1267,6 +2197,9 @@ status_t OMXCodec::setupMPEG4EncoderParameters(const sp<MetaData>& meta) {

                         if (err != OK) return err;

                         mpeg4type.eProfile = static_cast<OMX_VIDEO_MPEG4PROFILETYPE>(profileLevel.mProfile);

                         mpeg4type.eLevel = static_cast<OMX_VIDEO_MPEG4LEVELTYPE>(profileLevel.mLevel);

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +    mpeg4type.eLevel = OMX_VIDEO_MPEG4Level5;

                    +#endif

                         err = mOMX->setParameter(

                                 mNode, OMX_IndexParamVideoMpeg4, &mpeg4type, sizeof(mpeg4type));

                    @@ -1277,11 +2210,56 @@ status_t OMXCodec::setupMPEG4EncoderParameters(const sp<MetaData>& meta) {

                         CHECK_EQ(setupBitRate(bitRate), OK);

                         CHECK_EQ(setupErrorCorrectionParameters(), OK);

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +     //OMX_VIDEO_PARAM_MOTIONVECTORTYPE Settings

                    +    OMX_VIDEO_PARAM_MOTIONVECTORTYPE MotionVector;

                    +    OMX_VIDEO_PARAM_INTRAREFRESHTYPE RefreshParam;

                    +    InitOMXParams(&MotionVector);

                    +    MotionVector.nPortIndex = kPortIndexOutput;

                    +

                    +    err = mOMX->getParameter(

                    +            mNode, OMX_IndexParamVideoMotionVector, &MotionVector,sizeof(MotionVector));

                    +

                    +    MotionVector.nPortIndex = kPortIndexOutput;

                    +

                    +    // extra parameters - hardcoded

                    +    MotionVector.sXSearchRange = 16;

                    +    MotionVector.sYSearchRange = 16;

                    +    MotionVector.bFourMV =  OMX_FALSE;

                    +    MotionVector.eAccuracy =  OMX_Video_MotionVectorHalfPel ;

                    +    MotionVector.bUnrestrictedMVs = OMX_TRUE;

                    +

                    +    err = mOMX->setParameter(

                    +            mNode, OMX_IndexParamVideoMotionVector, &MotionVector,sizeof(MotionVector));

                    +

                    +    //OMX_VIDEO_PARAM_INTRAREFRESHTYPE Settings

                    +     InitOMXParams(&RefreshParam);

                    +    RefreshParam.nPortIndex = kPortIndexOutput;

                    +

                    +    err = mOMX->getParameter(

                    +            mNode, OMX_IndexParamVideoIntraRefresh, &RefreshParam,sizeof(RefreshParam));

                    +

                    +    // extra parameters - hardcoded based on PV defaults

                    +    RefreshParam.nPortIndex = kPortIndexOutput;

                    +    RefreshParam.eRefreshMode = OMX_VIDEO_IntraRefreshBoth;

                    +

                    +    if(((width >= 640) || (height >= 480)) && (frameRate > 15) && (bitRate > 2000000))

                    +    {

                    +        RefreshParam.nAirRef = 0;

                    +    }

                    +

                    +    err = mOMX->setParameter(mNode, OMX_IndexParamVideoIntraRefresh, &RefreshParam,sizeof(RefreshParam));

                    +#endif

                    +

                         return OK;

                     }

                     status_t OMXCodec::setupAVCEncoderParameters(const sp<MetaData>& meta) {

                         int32_t iFramesInterval, frameRate, bitRate;

                    +

                    +#if defined (TARGET_OMAP4) && defined (OMAP_ENHANCEMENT)

                    +    OMX_VIDEO_PARAM_VBSMCTYPE VbsmcType;

                    +#endif

                         bool success = meta->findInt32(kKeyBitRate, &bitRate);

                         success = success && meta->findInt32(kKeySampleRate, &frameRate);

                         success = success && meta->findInt32(kKeyIFramesInterval, &iFramesInterval);

                    @@ -1299,8 +2277,26 @@ status_t OMXCodec::setupAVCEncoderParameters(const sp<MetaData>& meta) {

                             OMX_VIDEO_PictureTypeI | OMX_VIDEO_PictureTypeP;

                         h264type.nSliceHeaderSpacing = 0;

                    +

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    h264type.nBFrames = OMX_NUM_B_FRAMES;

                    +    h264type.nPFrames = setPFramesSpacing(iFramesInterval, frameRate);

                    +

                    +#ifdef SUPPORT_B_FRAMES

                    +    int32_t remainder = h264type.nPFrames % (OMX_NUM_B_FRAMES + 1);

                    +    if(remainder)

                    +    {

                    +        LOGD("h264type.nPFrames=%d", (int) h264type.nPFrames);

                    +        h264type.nPFrames = h264type.nPFrames - remainder;

                    +        LOGD("adjusted to h264type.nPFrames=%d", (int) h264type.nPFrames);

                    +    }

                    +#endif

                    +

                    +#else

                         h264type.nBFrames = 0;   // No B frames support yet

                         h264type.nPFrames = setPFramesSpacing(iFramesInterval, frameRate);

                    +#endif

                    +

                         if (h264type.nPFrames == 0) {

                             h264type.nAllowedPictureTypes = OMX_VIDEO_PictureTypeI;

                         }

                    @@ -1311,16 +2307,34 @@ status_t OMXCodec::setupAVCEncoderParameters(const sp<MetaData>& meta) {

                         defaultProfileLevel.mLevel = h264type.eLevel;

                         err = getVideoProfileLevel(meta, defaultProfileLevel, profileLevel);

                         if (!(mQuirks & kCanNotSetVideoParameters) && err != OK) return err;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    h264type.eProfile = OMX_VIDEO_AVCProfileHigh;

                    +    h264type.eLevel = OMX_VIDEO_AVCLevel4;

                    +    LOGV("h264type.eProfile=%d, h264type.eLevel=%d", h264type.eProfile, h264type.eLevel);

                    +#else

                         h264type.eProfile = static_cast<OMX_VIDEO_AVCPROFILETYPE>(profileLevel.mProfile);

                         h264type.eLevel = static_cast<OMX_VIDEO_AVCLEVELTYPE>(profileLevel.mLevel);

                    +#endif

                    -    if (h264type.eProfile == OMX_VIDEO_AVCProfileBaseline) {

                    +    if (h264type.eProfile == OMX_VIDEO_AVCProfileBaseline

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +       || h264type.eProfile == OMX_VIDEO_AVCProfileMain

                    +       || h264type.eProfile == OMX_VIDEO_AVCProfileHigh

                    +#endif

                    +       ) {

                             h264type.bUseHadamard = OMX_TRUE;

                             h264type.nRefFrames = 1;

                             h264type.nRefIdx10ActiveMinus1 = 0;

                             h264type.nRefIdx11ActiveMinus1 = 0;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +        h264type.bEntropyCodingCABAC = OMX_TRUE;

                    +#else

                             h264type.bEntropyCodingCABAC = OMX_FALSE;

                    +#endif

                             h264type.bWeightedPPrediction = OMX_FALSE;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +        h264type.nWeightedBipredicitonMode = OMX_FALSE;

                    +#endif

                             h264type.bconstIpred = OMX_FALSE;

                             h264type.bDirect8x8Inference = OMX_FALSE;

                             h264type.bDirectSpatialTemporal = OMX_FALSE;

                    @@ -1347,6 +2361,68 @@ status_t OMXCodec::setupAVCEncoderParameters(const sp<MetaData>& meta) {

                         CHECK_EQ(setupBitRate(bitRate), OK);

                    +#if defined (TARGET_OMAP4) && defined (OMAP_ENHANCEMENT)

                    +    //OMX_IndexParamVideoMotionVector+

                    +    OMX_VIDEO_PARAM_MOTIONVECTORTYPE MotionVector;

                    +    InitOMXParams(&MotionVector);

                    +    MotionVector.nPortIndex = kPortIndexOutput;

                    +

                    +    err = mOMX->getParameter(mNode, OMX_IndexParamVideoMotionVector, &MotionVector, sizeof(MotionVector));

                    +    CHECK_EQ(err, OK);

                    +

                    +    // extra parameters - hardcoded

                    +    MotionVector.sXSearchRange = 16;

                    +    MotionVector.sYSearchRange = 16;

                    +    MotionVector.sXSearchRange = 144; // Set Horizontal search range to 144

                    +    MotionVector.sYSearchRange = 32; // Set Vertical search range to 32

                    +    MotionVector.bFourMV =  OMX_FALSE;

                    +    MotionVector.eAccuracy = OMX_Video_MotionVectorQuarterPel; // hardcoded

                    +    MotionVector.bUnrestrictedMVs = OMX_TRUE;

                    +

                    +    err = mOMX->setParameter(mNode, OMX_IndexParamVideoMotionVector, &MotionVector, sizeof(MotionVector));

                    +    CHECK_EQ(err, OK);

                    +

                    +    //OMX_IndexParamVideoIntraRefresh+

                    +    OMX_VIDEO_PARAM_INTRAREFRESHTYPE RefreshParam;

                    +    InitOMXParams(&RefreshParam);

                    +    RefreshParam.nPortIndex = kPortIndexOutput;

                    +

                    +    err = mOMX->getParameter(mNode, OMX_IndexParamVideoIntraRefresh, &RefreshParam, sizeof(RefreshParam));

                    +    CHECK_EQ(err, OK);

                    +

                    +    // extra parameters - hardcoded

                    +    RefreshParam.nPortIndex = kPortIndexOutput;

                    +    RefreshParam.eRefreshMode = OMX_VIDEO_IntraRefreshMax;//OMX_VIDEO_IntraRefreshBoth;

                    +    RefreshParam.nCirMBs = 0; //TO DO: need to confirm again.

                    +

                    +    err = mOMX->setParameter(mNode, OMX_IndexParamVideoIntraRefresh, &RefreshParam, sizeof(RefreshParam));

                    +    CHECK_EQ(err, OK);

                    +

                    +    int32_t isS3DEnabled = false;

                    +    success = success && meta->findInt32(kKeyS3dSupported, &isS3DEnabled);

                    +    CHECK(success);

                    +

                    +    //OMX_TI_IndexParamVideoEncoderPreset+

                    +    CHECK_EQ(setupEncoderPresetParams(isS3DEnabled), OK);

                    +

                    +    //OMX_TI_IndexParamVideoFrameDataContentSettings+

                    +    if(isS3DEnabled)

                    +        CHECK_EQ(setupEncoderFrameDataContentParams(meta), OK);

                    +

                    +    //OMX_IndexParamVideoVBSMC+

                    +    InitOMXParams(&VbsmcType);

                    +    VbsmcType.nPortIndex = kPortIndexOutput;

                    +

                    +    err = mOMX->getParameter(mNode, OMX_IndexParamVideoVBSMC, &VbsmcType,sizeof(VbsmcType));

                    +    CHECK_EQ(err, OK);

                    +

                    +    VbsmcType.b16x16 = OMX_TRUE;

                    +    VbsmcType.b16x8 = VbsmcType.b8x16 = VbsmcType.b8x8 = VbsmcType.b8x4 = VbsmcType.b4x8 = VbsmcType.b4x4 = OMX_FALSE;

                    +

                    +    err =mOMX->setParameter(mNode, OMX_IndexParamVideoVBSMC, &VbsmcType,sizeof(VbsmcType));

                    +    CHECK_EQ(err, OK);

                    +#endif

                    +

                         return OK;

                     }

                    @@ -1361,6 +2437,18 @@ status_t OMXCodec::setVideoOutputFormat(

                             compressionFormat = OMX_VIDEO_CodingMPEG4;

                         } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_H263, mime)) {

                             compressionFormat = OMX_VIDEO_CodingH263;

                    +#if defined(OMAP_ENHANCEMENT)

                    +#if defined(TARGET_OMAP4)

                    +    } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_VP6, mime)) {

                    +        compressionFormat = (OMX_VIDEO_CODINGTYPE)OMX_VIDEO_CodingVP6;

                    +    } else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_VP7, mime)) {

                    +        compressionFormat = (OMX_VIDEO_CODINGTYPE)OMX_VIDEO_CodingVP7;

                    +#endif

                    +    }

                    +    else if (!strcasecmp(MEDIA_MIMETYPE_VIDEO_WMV , mime))

                    +    {

                    +        compressionFormat = OMX_VIDEO_CodingWMV;

                    +#endif

                         } else {

                             LOGE("Not a supported video mime type: %s", mime);

                             CHECK(!"Should not be here. Not a supported video mime type.");

                    @@ -1419,6 +2507,9 @@ status_t OMXCodec::setVideoOutputFormat(

                                    || format.eColorFormat == OMX_COLOR_FormatCbYCrY

                                    || format.eColorFormat == OMX_QCOM_COLOR_FormatYVU420SemiPlanar

                                    || format.eColorFormat == QOMX_COLOR_FormatYVU420PackedSemiPlanar32m4ka

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +               || format.eColorFormat == OMX_COLOR_FormatYUV420PackedSemiPlanar

                    +#endif

                                    || format.eColorFormat == QOMX_COLOR_FormatYUV420PackedSemiPlanar64x32Tile2m8ka);

                             err = mOMX->setParameter(

                    @@ -1442,6 +2533,18 @@ status_t OMXCodec::setVideoOutputFormat(

                         CHECK_EQ(err, OK);

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    if(!strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.DECODER")) {

                    +                //update input buffer size as per resolution

                    +                def.nBufferSize = width * height;

                    +

                    +         if(mQuirks & OMXCodec::kThumbnailMode){

                    +                def.nBufferCountActual = 1;

                    +         }else{

                    +                def.nBufferCountActual = 4;

                    +    }

                    +    }

                    +#else

                     #if 1

                         // XXX Need a (much) better heuristic to compute input buffer sizes.

                         const size_t X = 64 * 1024;

                    @@ -1449,6 +2552,7 @@ status_t OMXCodec::setVideoOutputFormat(

                             def.nBufferSize = X;

                         }

                     #endif

                    +#endif

                         CHECK_EQ(def.eDomain, OMX_PortDomainVideo);

                    @@ -1480,12 +2584,102 @@ status_t OMXCodec::setVideoOutputFormat(

                             (((width + 15) & -16) * ((height + 15) & -16) * 3) / 2;  // YUV420

                     #endif

                    +#if defined(OMAP_ENHANCEMENT)

                    +#if defined(TARGET_OMAP4)

                    +    if(!strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.DECODER")) {

                    +

                    +        OMX_CONFIG_RECTTYPE tParamStruct;

                    +        InitOMXParams(&tParamStruct);

                    +        tParamStruct.nPortIndex = kPortIndexOutput;

                    +

                    +        err = mOMX->getParameter(

                    +                mNode, (OMX_INDEXTYPE)OMX_TI_IndexParam2DBufferAllocDimension, &tParamStruct, sizeof(tParamStruct));

                    +

                    +        CHECK_EQ(err, OK);

                    +

                    +        video_def->nStride = tParamStruct.nWidth;

                    +        mStride = video_def->nStride ;

                    +

                    +        if(mQuirks & kInterlacedOutputContent){

                    +            video_def->eColorFormat = (OMX_COLOR_FORMATTYPE) OMX_TI_COLOR_FormatYUV420PackedSemiPlanar_Sequential_TopBottom;

                    +        }

                    +

                    +        video_def->xFramerate = mVideoFPS << 16;

                    +    }

                    +

                    +    if(!(mQuirks & OMXCodec::kThumbnailMode)){

                    +            //playback usecase. Calculate the buffer count to take display optimal buffer count into account

                    +            //Note: this is applicable for both ducati and h/w codecs

                    +            //def.nBufferCountMin    => minimum no of buffers required on a port (communicated by codec)

                    +            //def.nBufferCountActual => actual no. of buffers allocated on a port (communicated to codec)

                    +            def.nBufferCountActual = def.nBufferCountMin + (2 * NUM_BUFFERS_TO_BE_QUEUED_FOR_OPTIMAL_PERFORMANCE);

                    +    }

                    +#elif defined(TARGET_OMAP3)

                    +    // Suppress output buffer count for OMAP3

                    +    // The number of VRFB buffer, which is used for rotation, is 4.

                    +    // Output buffer count can not exceed VRFB buffer count.

                    +    if (def.nBufferCountActual > OUTPUT_BUFFER_COUNT)

                    +        def.nBufferCountActual = OUTPUT_BUFFER_COUNT;

                    +#endif

                    +#endif

                         video_def->nFrameWidth = width;

                         video_def->nFrameHeight = height;

                         err = mOMX->setParameter(

                                 mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    if(!strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.DECODER")) {

                    +

                    +        if(mQuirks & OMXCodec::kThumbnailMode){

                    +

                    +            LOGD("Thumbnail Mode");

                    +            //Get the calculated min buffer count

                    +            err = mOMX->getParameter(

                    +                    mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));

                    +            CHECK_EQ(err, OK);

                    +            CHECK_EQ(def.eDomain, OMX_PortDomainVideo);

                    +

                    +            //Thumbnail usecase. Set buffer count to optimal

                    +            def.nBufferCountActual = def.nBufferCountMin;

                    +

                    +            //Set the proper parameters again, as it is marshalled in Get_Parameter()

                    +            video_def->nFrameWidth = width;

                    +            video_def->nFrameHeight = height;

                    +

                    +            err = mOMX->setParameter(

                    +                    mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));

                    +            CHECK_EQ(err, OK);

                    +

                    +#if defined (NPA_BUFFERS)

                    +            CODEC_LOGV("Setting up the non-pre-annoucement mode");

                    +            OMX_TI_PARAM_BUFFERPREANNOUNCE PreAnnouncement;

                    +            InitOMXParams(&PreAnnouncement);

                    +            PreAnnouncement.nPortIndex = def.nPortIndex;

                    +            err = mOMX->getParameter(

                    +                    mNode, (OMX_INDEXTYPE)OMX_TI_IndexParamBufferPreAnnouncement, &PreAnnouncement, sizeof(PreAnnouncement));

                    +               if (err != OMX_ErrorNone)

                    +            {

                    +                CODEC_LOGE("get OMX_TI_IndexParamBufferPreAnnouncement err : %x",err);

                    +            }

                    +

                    +            //Set the pre-annoucement to be false. i.e we will provide the buffer when we get it from camera.

                    +            PreAnnouncement.bEnabled = OMX_FALSE;

                    +            err = mOMX->setParameter(

                    +                    mNode, (OMX_INDEXTYPE)OMX_TI_IndexParamBufferPreAnnouncement, &PreAnnouncement, sizeof(PreAnnouncement));

                    +            if (err != OMX_ErrorNone)

                    +            {

                    +                CODEC_LOGE("set OMX_TI_IndexParamBufferPreAnnouncement err : %x",err);

                    +            }

                    +

                    +            mNumberOfNPABuffersSent = 0;

                    +            mThumbnailEOSSent = 0;

                    +#endif

                    +

                    +        }

                    +   }

                    +#endif

                    +

                         return err;

                     }

                    @@ -1547,6 +2741,22 @@ void OMXCodec::setComponentRole(

                                 "video_decoder.mpeg4", "video_encoder.mpeg4" },

                             { MEDIA_MIMETYPE_VIDEO_H263,

                                 "video_decoder.h263", "video_encoder.h263" },

                    +#if defined(OMAP_ENHANCEMENT)

                    +#if defined(TARGET_OMAP4)

                    +        { MEDIA_MIMETYPE_VIDEO_VP6,

                    +            "video_decoder.vp6", NULL },

                    +        { MEDIA_MIMETYPE_VIDEO_VP7,

                    +            "video_decoder.vp7", NULL },

                    +#endif

                    +        { MEDIA_MIMETYPE_VIDEO_WMV,

                    +            "video_decoder.wmv", "video_encoder.wmv" },

                    +        { MEDIA_MIMETYPE_AUDIO_WMA,

                    +            "audio_decoder.wma", "audio_encoder.wma" },

                    +        { MEDIA_MIMETYPE_AUDIO_WMAPRO,

                    +            "audio_decoder.wmapro", "audio_encoder.wmapro" },

                    +        { MEDIA_MIMETYPE_AUDIO_WMALSL,

                    +            "audio_decoder.wmalsl", "audio_encoder.wmalsl" },

                    +#endif

                         };

                         static const size_t kNumMimeToRole =

                    @@ -1675,7 +2885,40 @@ status_t OMXCodec::allocateBuffersOnPort(OMX_U32 portIndex) {

                                 portIndex == kPortIndexInput ? "input" : "output");

                         size_t totalSize = def.nBufferCountActual * ((def.nBufferSize + 31) & (~31));

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4) && defined (NPA_BUFFERS)

                    +            if( !strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.DECODER") &&

                    +                (mQuirks & OMXCodec::kThumbnailMode) &&

                    +                (portIndex == kPortIndexOutput)){

                    +            totalSize = (THUMBNAIL_BUFFERS_NPA_MODE * def.nBufferSize)

                    +                        + ((def.nBufferCountActual - THUMBNAIL_BUFFERS_NPA_MODE) * NPA_BUFFER_SIZE);

                    +            }

                    +#endif

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +    bool useExternallyAllocatedBuffers = false;

                    +

                    +    if ((!strcmp(mComponentName, "OMX.TI.Video.Decoder") ||

                    +         !strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.DECODER") ||

                    +         !strcmp(mComponentName, "OMX.TI.720P.Decoder")) &&

                    +        (portIndex == kPortIndexOutput) &&

                    +        (mExtBufferAddresses.size() == def.nBufferCountActual)

                    +#if defined(TARGET_OMAP4)

                    +        && !(mQuirks & OMXCodec::kThumbnailMode)

                    +#endif

                    +        ){

                    +

                    +        // One must use overlay buffers for TI video decoder output port.

                    +        // So, do not allocate memory here.

                    +        useExternallyAllocatedBuffers = true;

                    +    }

                    +    else{

                    +        mDealer[portIndex] = new MemoryDealer(totalSize, "OMXCodec");

                    +    }

                    +

                    +    sp<IMemory> mem;

                    +#else

                         mDealer[portIndex] = new MemoryDealer(totalSize, "OMXCodec");

                    +#endif

                     #ifdef USE_GETBUFFERINFO

                         sp<IMemoryHeap> pFrameHeap = NULL;

                    @@ -1713,12 +2956,54 @@ status_t OMXCodec::allocateBuffersOnPort(OMX_U32 portIndex) {

                     #endif

                         for (OMX_U32 i = 0; i < def.nBufferCountActual; ++i) {

                    +#ifdef OMAP_ENHANCEMENT

                    +        if (useExternallyAllocatedBuffers){

                    +            mem = mExtBufferAddresses[i];

                    +        }

                    +        else{

                    +

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4) && defined (NPA_BUFFERS)

                    +            if( !strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.DECODER") &&

                    +                (mQuirks & OMXCodec::kThumbnailMode) &&

                    +                (portIndex == kPortIndexOutput) &&

                    +                (i>=THUMBNAIL_BUFFERS_NPA_MODE))

                    +                mem = mDealer[portIndex]->allocate(NPA_BUFFER_SIZE);

                    +            else

                    +#endif

                    +            {

                    +                if(portIndex == kPortIndexOutput)

                    +                {

                    +                    def.nBufferSize = ((def.nBufferSize + CACHELINE_BOUNDARY_MEMALIGNMENT - 1) &

                    +                      ~(CACHELINE_BOUNDARY_MEMALIGNMENT - 1));

                    +                }

                    +                mem = mDealer[portIndex]->allocate(def.nBufferSize);

                    +            }

                    +        }

                    +#else

                             sp<IMemory> mem = mDealer[portIndex]->allocate(def.nBufferSize);

                    +#endif

                             CHECK(mem.get() != NULL);

                             BufferInfo info;

                             info.mData = NULL;

                             info.mSize = def.nBufferSize;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +        //Update Output buffers range as per 2D buffer requirement.

                    +        //Doubling size to contain (nFilledLen + nOffset) check. Extra range is harmless here.

                    +        if (!strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.DECODER")){

                    +            if(useExternallyAllocatedBuffers)

                    +            {

                    +                OMX_VIDEO_PORTDEFINITIONTYPE *videoDef = &def.format.video;

                    +                int32_t padded_height;

                    +

                    +                if (!(mOutputFormat->findInt32(kKeyPaddedHeight, &padded_height))) {

                    +                    padded_height =  videoDef->nFrameHeight;

                    +                }

                    +

                    +                info.mSize = ARM_4K_PAGE_SIZE * padded_height * 2;

                    +            }

                    +        }

                    +#endif

                             IOMX::buffer_id buffer;

                             if (portIndex == kPortIndexInput

                    @@ -1746,7 +3031,18 @@ status_t OMXCodec::allocateBuffersOnPort(OMX_U32 portIndex) {

                                             mNode, portIndex, mem, &buffer);

                                 }

                             } else {

                    -#ifdef USE_GETBUFFERINFO

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +                if((!strcmp(mComponentName,"OMX.TI.DUCATI1.VIDEO.H264E")

                    +                                        || !strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.MPEG4E"))

                    +                                && (portIndex == kPortIndexInput)

                    +                                && !(mQuirks & kRequiresAllocateBufferOnInputPorts) ){

                    +                        sp<IMemory> tempmem = mem;

                    +                        tempmem.clear();

                    +                        err = mOMX->useBuffer(mNode, portIndex, tempmem, &buffer, mem->size());

                    +                } else {

                    +                        err = mOMX->useBuffer(mNode, portIndex, mem, &buffer, mem->size());

                    +                }

                    +#elif defined(USE_GETBUFFERINFO)

                                 if(pFrameHeap != NULL && mIsEncoder && (mQuirks & kAvoidMemcopyInputRecordingFrames)) {

                                     ssize_t temp_offset = i * alignedSize;

                                     size_t temp_size = size;

                    @@ -1758,10 +3054,11 @@ status_t OMXCodec::allocateBuffersOnPort(OMX_U32 portIndex) {

                                         temp_size, alignedSize, pFrame->pointer(), pFrameHeap->getSize());

                                     err = mOMX->useBuffer(mNode, portIndex, pFrame, &buffer);

                                 } else

                    -#endif

                    +#else

                                 {

                                     err = mOMX->useBuffer(mNode, portIndex, mem, &buffer);

                                 }

                    +#endif

                             }

                             if (err != OK) {

                    @@ -1775,6 +3072,9 @@ status_t OMXCodec::allocateBuffersOnPort(OMX_U32 portIndex) {

                             info.mBuffer = buffer;

                             info.mOwnedByComponent = false;

                    +#ifdef OMAP_ENHANCEMENT

                    +        info.mOwnedByPlayer = false;

                    +#endif

                             info.mMem = mem;

                             info.mMediaBuffer = NULL;

                    @@ -1901,6 +3201,13 @@ void OMXCodec::on_message(const omx_message &msg) {

                                          "a FILL_BUFFER_DONE.", buffer);

                                 }

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4) && defined (NPA_BUFFERS)

                    +        if( !strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.DECODER") &&

                    +            (mQuirks & OMXCodec::kThumbnailMode) ){

                    +            if (mNumberOfNPABuffersSent > 0)

                    +                mNumberOfNPABuffersSent--;

                    +        }

                    +#endif

                                 info->mOwnedByComponent = false;

                                 if (mPortStatus[kPortIndexOutput] == DISABLING) {

                    @@ -1960,6 +3267,9 @@ void OMXCodec::on_message(const omx_message &msg) {

                                     buffer->meta_data()->clear();

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +                buffer->meta_data()->setInt32(kKeyStride, mStride);

                    +#endif

                                     buffer->meta_data()->setInt64(

                                             kKeyTime, msg.u.extended_buffer_data.timestamp);

                    @@ -1970,6 +3280,11 @@ void OMXCodec::on_message(const omx_message &msg) {

                                         buffer->meta_data()->setInt32(kKeyIsCodecConfig, true);

                                     }

                    +#if defined(TARGET_OMAP4) && defined(OMAP_ENHANCEMENT)

                    +                if (msg.u.extended_buffer_data.flags & OMX_TI_BUFFERFLAG_DETACHEDEXTRADATA)

                    +                    buffer->meta_data()->setInt32(kKeyIsExtraData, true);

                    +#endif

                    +

                                     if (mQuirks & kOutputBuffersAreUnreadable) {

                                         buffer->meta_data()->setInt32(kKeyIsUnreadable, true);

                                     }

                    @@ -1986,7 +3301,6 @@ void OMXCodec::on_message(const omx_message &msg) {

                                         CODEC_LOGV("No more output data.");

                                         mNoMoreOutputData = true;

                                     }

                    -

                                     if (mTargetTimeUs >= 0) {

                                         CHECK(msg.u.extended_buffer_data.timestamp <= mTargetTimeUs);

                    @@ -2059,6 +3373,7 @@ void OMXCodec::onEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) {

                             case OMX_EventPortSettingsChanged:

                             {

                    +#ifndef OMAP_ENHANCEMENT

                                 if(mState == EXECUTING)

                                     CODEC_LOGV("OMX_EventPortSettingsChanged(port=%ld, data2=0x%08lx)",

                                            data1, data2);

                    @@ -2071,6 +3386,9 @@ void OMXCodec::onEvent(OMX_EVENTTYPE event, OMX_U32 data1, OMX_U32 data2) {

                                     }

                                 else

                                   LOGE("Ignore PortSettingsChanged event \n");

                    +#else

                    +            onPortSettingsChanged(data1);

                    +#endif

                                 break;

                             }

                    @@ -2192,10 +3510,57 @@ void OMXCodec::onCmdComplete(OMX_COMMANDTYPE cmd, OMX_U32 data) {

                                     mOutputPortSettingsHaveChanged =

                                         formatHasNotablyChanged(oldOutputFormat, mOutputFormat);

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +                if( !strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.DECODER")){

                    +                    if (mExtBufferAddresses.size() == 0) /* Any Ducati codec non-overlay usecase */

                    +                    {

                    +                        LOGD("OMX_CommandPortDisable Done. Reenabling port for non-overlay playback usecase");

                    +

                    +                        /*Since we are mostly dealing 1D buffers here,

                    +                          nStride has to be updated as nFrameWidth will change on portreconfig

                    +                          */

                    +                        OMX_PARAM_PORTDEFINITIONTYPE def;

                    +                        InitOMXParams(&def);

                    +                        def.nPortIndex = kPortIndexOutput;

                    +

                    +                        status_t err = mOMX->getParameter(

                    +                              mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));

                    +                        CHECK_EQ(err, OK);

                    +

                    +                        OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video;

                    +

                    +                        int32_t padded_width;

                    +                        CHECK(mOutputFormat->findInt32(kKeyPaddedWidth, &padded_width));

                    +                        video_def->nStride = padded_width;

                    +                        mStride = video_def->nStride;

                    +

                    +                        LOGE("Updating video_def->nStride with new width %d", (int) video_def->nStride);

                    +

                    +                        err = mOMX->setParameter(

                    +                                     mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));

                    +

                    +

                    +                        enablePortAsync(portIndex);

                    +

                    +                        err = allocateBuffersOnPort(portIndex);

                    +                        CHECK_EQ(err, OK);

                    +                   }else

                    +                   {

                    +                      LOGD("OMX_CommandPortDisable Done. Not enabling port till overlay buffers are available");

                    +                   }

                    +                } else

                    +                {

                                     enablePortAsync(portIndex);

                                     status_t err = allocateBuffersOnPort(portIndex);

                                     CHECK_EQ(err, OK);

                    +                }

                    +#else

                    +                enablePortAsync(portIndex);

                    +

                    +                status_t err = allocateBuffersOnPort(portIndex);

                    +                CHECK_EQ(err, OK);

                    +#endif

                                 }

                                 break;

                             }

                    @@ -2338,6 +3703,12 @@ void OMXCodec::onStateChange(OMX_STATETYPE newState) {

                             case OMX_StateLoaded:

                             {

                    +#ifdef OMAP_ENHANCEMENT

                    +            if(LOADED == mState)

                    +            {

                    +                break;

                    +            }

                    +#endif

                                 CHECK_EQ(mState, IDLE_TO_LOADED);

                                 CODEC_LOGV("Now Loaded.");

                    @@ -2381,7 +3752,11 @@ status_t OMXCodec::freeBuffersOnPort(

                         for (size_t i = buffers->size(); i-- > 0;) {

                             BufferInfo *info = &buffers->editItemAt(i);

                    -        if (onlyThoseWeOwn && info->mOwnedByComponent) {

                    +#ifdef OMAP_ENHANCEMENT

                    +        if (onlyThoseWeOwn && (info->mOwnedByComponent || info->mOwnedByPlayer) ) {

                    +#else

                    +        if (onlyThoseWeOwn && info->mOwnedByComponent ) {

                    +#endif

                                 continue;

                             }

                    @@ -2421,6 +3796,34 @@ void OMXCodec::onPortSettingsChanged(OMX_U32 portIndex) {

                         CHECK_EQ(portIndex, kPortIndexOutput);

                         setState(RECONFIGURING);

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    LOGD("[%s] PORT_SETTINGS_CHANGED(%d)",mComponentName, (int)portIndex);

                    +

                    +#if defined (NPA_BUFFERS)

                    +    //reset NPA buffer counter on port reconfig.

                    +    mNumberOfNPABuffersSent = 0;

                    +  mThumbnailEOSSent = 0;

                    +#endif

                    +

                    +    if( !strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.DECODER"))

                    +    {

                    +        /* update new port settings, since renderer needs new WxH for new buffers */

                    +        initOutputFormat(mSource->getFormat());

                    +

                    +        /* For thumbnail color conversion routine will require unpadded display WxH

                    +           update it in video-source meta data here, to be used later during color conversion */

                    +        OMX_PARAM_PORTDEFINITIONTYPE def;

                    +        InitOMXParams(&def);

                    +        def.nPortIndex = kPortIndexOutput;

                    +        status_t err = mOMX->getParameter(

                    +                mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));

                    +        CHECK_EQ(err, OK);

                    +        OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video;

                    +        mSource->getFormat()->setInt32(kKeyWidth, video_def->nFrameWidth);

                    +        mSource->getFormat()->setInt32(kKeyHeight, video_def->nFrameHeight);

                    +        LOGI("Updated source WxH %dx%d", (int) video_def->nFrameWidth, (int) video_def->nFrameHeight);

                    +    }

                    +#endif

                         if (mQuirks & kNeedsFlushBeforeDisable) {

                             if (!flushPortAsync(portIndex)) {

                                 onCmdComplete(OMX_CommandFlush, portIndex);

                    @@ -2459,7 +3862,6 @@ bool OMXCodec::flushPortAsync(OMX_U32 portIndex) {

                     void OMXCodec::disablePortAsync(OMX_U32 portIndex) {

                         CHECK(mState == EXECUTING || mState == RECONFIGURING);

                    -

                         CHECK_EQ(mPortStatus[portIndex], ENABLED);

                         mPortStatus[portIndex] = DISABLING;

                    @@ -2501,7 +3903,26 @@ void OMXCodec::fillOutputBuffers() {

                         Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexOutput];

                         for (size_t i = 0; i < buffers->size(); ++i) {

                    +#ifdef OMAP_ENHANCEMENT

                    +        if ((*buffers)[i].mOwnedByPlayer) {

                    +            continue;

                    +        }

                    +#endif

                    +#if defined(TARGET_OMAP4) && defined(OMAP_ENHANCEMENT)

                    +        if (!(*buffers)[i].mOwnedByComponent) {

                    +

                    +#if defined (NPA_BUFFERS)

                    +        if( !strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.DECODER") &&

                    +            (mQuirks & OMXCodec::kThumbnailMode) ){

                    +            if(mNumberOfNPABuffersSent++ >= THUMBNAIL_BUFFERS_NPA_MODE)

                    +                return;

                    +        }

                    +#endif

                    +            fillOutputBuffer(&buffers->editItemAt(i));

                    +        }

                    +#else

                             fillOutputBuffer(&buffers->editItemAt(i));

                    +#endif

                         }

                     }

                    @@ -2516,8 +3937,13 @@ void OMXCodec::drainInputBuffers() {

                             //and camera will not give any more unless we give release

                             if (mIsEncoder && (mQuirks & kAvoidMemcopyInputRecordingFrames) && (i == 4))

                                 break;

                    -#endif

                    +#elif defined(OMAP_ENHANCEMENT)

                    +        if (!(*buffers)[i].mOwnedByComponent) {

                    +            drainInputBuffer(&buffers->editItemAt(i));

                    +        }

                    +#else

                             drainInputBuffer(&buffers->editItemAt(i));

                    +#endif

                         }

                     }

                    @@ -2555,14 +3981,13 @@ void OMXCodec::drainInputBuffer(BufferInfo *info) {

                             CODEC_LOGV("calling emptyBuffer with codec specific data");

                    +        info->mOwnedByComponent = true;

                             status_t err = mOMX->emptyBuffer(

                                     mNode, info->mBuffer, 0, size,

                                     OMX_BUFFERFLAG_ENDOFFRAME | OMX_BUFFERFLAG_CODECCONFIG,

                                     0);

                             CHECK_EQ(err, OK);

                    -        info->mOwnedByComponent = true;

                    -

                             ++mCodecSpecificDataIndex;

                             return;

                         }

                    @@ -2578,9 +4003,20 @@ void OMXCodec::drainInputBuffer(BufferInfo *info) {

                         size_t offset = 0;

                         int32_t n = 0;

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +    uint32_t omx_offset = 0;

                    +#endif

                    +

                         for (;;) {

                             MediaBuffer *srcBuffer;

                             MediaSource::ReadOptions options;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +        MediaBuffer *tmpBuffer = NULL;

                    +        if (!mIsEncoder) {

                    +            srcBuffer = new MediaBuffer(info->mData, info->mSize);

                    +            tmpBuffer = srcBuffer;

                    +        }

                    +#endif

                             if (mSkipTimeUs >= 0) {

                                 options.setSkipFrame(mSkipTimeUs);

                             }

                    @@ -2617,6 +4053,17 @@ void OMXCodec::drainInputBuffer(BufferInfo *info) {

                             }

                             if (err != OK) {

                    +#ifdef OMAP_ENHANCEMENT

                    +            if(mQuirks & kDecoderCantRenderSmallClips &&

                    +               err == ERROR_END_OF_STREAM){

                    +                static char mBufferAfterEos = 0;

                    +                if(!mBufferAfterEos){

                    +                    mBufferAfterEos = 1;

                    +                    break;

                    +                }

                    +                mBufferAfterEos = 0;

                    +            }

                    +#endif

                                 signalEOS = true;

                                 mFinalStatus = err;

                                 mSignalledEOS = true;

                    @@ -2651,14 +4098,34 @@ void OMXCodec::drainInputBuffer(BufferInfo *info) {

                                 CHECK(mOMXLivesLocally && offset == 0);

                                 OMX_BUFFERHEADERTYPE *header = (OMX_BUFFERHEADERTYPE *) info->mBuffer;

                                 header->pBuffer = (OMX_U8 *) srcBuffer->data() + srcBuffer->range_offset();

                    +#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +            //closed loop.

                    +            if(!strcmp(mComponentName,"OMX.TI.DUCATI1.VIDEO.H264E")

                    +               || !strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.MPEG4E")) {

                    +                srcBuffer->meta_data()->findInt32(kKeyOffset,(int32_t *) &omx_offset);

                    +            }

                    +

                    +            releaseBuffer = false;

                    +            info->mMediaBuffer = srcBuffer;

                    +#endif

                             } else {

                                 if (mQuirks & kStoreMetaDataInInputVideoBuffers) {

                                     releaseBuffer = false;

                                     info->mMediaBuffer = srcBuffer;

                                 }

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +        if (tmpBuffer != srcBuffer) {

                    +            memcpy((uint8_t *)info->mData + offset,

                    +                    (const uint8_t *)srcBuffer->data() + srcBuffer->range_offset(),

                    +                    srcBuffer->range_length());

                    +            if (tmpBuffer)

                    +                tmpBuffer->release();

                    +        }

                    +#else

                                 memcpy((uint8_t *)info->mData + offset,

                                         (const uint8_t *)srcBuffer->data() + srcBuffer->range_offset(),

                                         srcBuffer->range_length());

                    +#endif

                             }

                             int64_t lastBufferTimeUs;

                    @@ -2697,6 +4164,30 @@ void OMXCodec::drainInputBuffer(BufferInfo *info) {

                         }

                         OMX_U32 flags = OMX_BUFFERFLAG_ENDOFFRAME;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4) && defined (NPA_BUFFERS)

                    +    if(mQuirks & OMXCodec::kThumbnailMode) {

                    +        CODEC_LOGV("Sending eos flag %d",mThumbnailEOSSent);

                    +        if(mThumbnailEOSSent == 1) {

                    +            CODEC_LOGV("Previously EOS was sent out for thumbnail mode");

                    +            // Returning for this point since we dont want to send

                    +            // any more input buffers to the codec as it is expected to

                    +            // flush out the frame from codec since we have send EOS

                    +            // flag in input previous buffer.

                    +            return;

                    +        }

                    +        mThumbnailEOSSent = 1;

                    +        flags |= OMX_BUFFERFLAG_EOS;

                    +    }

                    +#endif

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +

                    +    if(!strcmp(mComponentName,"OMX.TI.DUCATI1.VIDEO.H264E")

                    +       || !strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.MPEG4E"))

                    +    {

                    +        flags |= OMX_BUFFERFLAG_SYNCFRAME;

                    +        flags |= OMX_BUFFERHEADERFLAG_MODIFIED;

                    +    }

                    +#endif

                         if (signalEOS) {

                             flags |= OMX_BUFFERFLAG_EOS;

                    @@ -2709,20 +4200,36 @@ void OMXCodec::drainInputBuffer(BufferInfo *info) {

                                    info->mBuffer, offset,

                                    timestampUs, timestampUs / 1E6);

                    +    info->mOwnedByComponent = true;

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    if(!strcmp(mComponentName,"OMX.TI.DUCATI1.VIDEO.H264E")

                    +       || !strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.MPEG4E")) {

                    +        CODEC_LOGV("Calling emptybuffer with offset value =%ld ",omx_offset);

                    +

                    +        err = mOMX->emptyBuffer(

                    +            mNode, info->mBuffer, omx_offset, offset,

                    +            flags, timestampUs);

                    +    } else {

                    +        err = mOMX->emptyBuffer(

                    +            mNode, info->mBuffer, 0, offset,

                    +            flags, timestampUs);

                    +    }

                    +#else

                         err = mOMX->emptyBuffer(

                                 mNode, info->mBuffer, 0, offset,

                                 flags, timestampUs);

                    +#endif

                         if (err != OK) {

                             setState(ERROR);

                             return;

                         }

                    -    info->mOwnedByComponent = true;

                    -

                         // This component does not ever signal the EOS flag on output buffers,

                         // Thanks for nothing.

                    -    if (mSignalledEOS && !strcmp(mComponentName, "OMX.TI.Video.encoder")) {

                    +    if (mSignalledEOS &&

                    +            (!strcmp(mComponentName, "OMX.TI.Video.encoder") ||

                    +             !strcmp(mComponentName, "OMX.TI.720P.Encoder"))) {

                             mNoMoreOutputData = true;

                             mBufferFilled.signal();

                         }

                    @@ -2738,6 +4245,7 @@ void OMXCodec::fillOutputBuffer(BufferInfo *info) {

                         }

                         CODEC_LOGV("Calling fill_buffer on buffer %p", info->mBuffer);

                    +    info->mOwnedByComponent = true;

                         status_t err = mOMX->fillBuffer(mNode, info->mBuffer);

                         if (err != OK) {

                    @@ -2746,8 +4254,6 @@ void OMXCodec::fillOutputBuffer(BufferInfo *info) {

                             setState(ERROR);

                             return;

                         }

                    -

                    -    info->mOwnedByComponent = true;

                     }

                     void OMXCodec::drainInputBuffer(IOMX::buffer_id buffer) {

                    @@ -2766,8 +4272,19 @@ void OMXCodec::fillOutputBuffer(IOMX::buffer_id buffer) {

                         Vector<BufferInfo> *buffers = &mPortBuffers[kPortIndexOutput];

                         for (size_t i = 0; i < buffers->size(); ++i) {

                             if ((*buffers)[i].mBuffer == buffer) {

                    -            fillOutputBuffer(&buffers->editItemAt(i));

                    -            return;

                    +#if defined(TARGET_OMAP4) && defined(OMAP_ENHANCEMENT)

                    +            if (!(*buffers)[i].mOwnedByComponent) {

                    +                fillOutputBuffer(&buffers->editItemAt(i));

                    +                return;

                    +            }

                    +            else {

                    +                CODEC_LOGV("ALREADY OWNING THE BUFFER. RETURNING");

                    +                return;

                    +            }

                    +#else

                    +        fillOutputBuffer(&buffers->editItemAt(i));

                    +        return;

                    +#endif

                             }

                         }

                    @@ -3218,10 +4735,96 @@ sp<MetaData> OMXCodec::getFormat() {

                         return mOutputFormat;

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +void OMXCodec::setBuffers(Vector< sp<IMemory> > mBufferAddresses, bool portReconfig){

                    +    mExtBufferAddresses = mBufferAddresses;

                    +

                    +#ifdef TARGET_OMAP4

                    +    if(!portReconfig){

                    +

                    +        OMX_PARAM_PORTDEFINITIONTYPE def;

                    +        InitOMXParams(&def);

                    +        def.nPortIndex = kPortIndexOutput;

                    +

                    +        status_t err = mOMX->getParameter(

                    +                        mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));

                    +        CHECK_EQ(err, OK);

                    +        //reconfigure codec with the number of buffers actually got created

                    +        //by the Hardware Renderer

                    +        def.nBufferCountActual = mExtBufferAddresses.size();

                    +

                    +        //Update stride for 2D buffers

                    +        OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video;

                    +        video_def->nStride = ARM_4K_PAGE_SIZE;

                    +        mStride = video_def->nStride;

                    +

                    +        err = mOMX->setParameter(

                    +                     mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));

                    +        //CHECK_EQ(err, OK);

                    +    }else{

                    +

                    +        if(portReconfig && mState!= RECONFIGURING)

                    +        {

                    +            LOGE("Extra setbuffer(portreconfig=true) call when port reconfigure is done. REPORT THIS");

                    +            return;

                    +        }

                    +

                    +        // Wait till all fillbuffer done events are handled cleanly

                    +        usleep(10000); 

                    +

                    +        // Flush all the buffers

                    +        freeBuffersOnPort(kPortIndexOutput);

                    +

                    +        //disable the port if it enabled

                    +        if (mPortStatus[kPortIndexOutput] == ENABLED) {

                    +            disablePortAsync(kPortIndexOutput);

                    +        }

                    +

                    +        int32_t retrycount = 0;

                    +        while(mPortStatus[kPortIndexOutput] == DISABLING){

                    +            usleep(2000); // 2 mS

                    +            LOGD("(%d) Output port is DISABLING.. Waiting for port to be disabled.. %d",retrycount,mPortStatus[kPortIndexOutput] );

                    +            retrycount++;

                    +            CHECK(retrycount < 100);

                    +        }

                    +

                    +        OMX_PARAM_PORTDEFINITIONTYPE def;

                    +        InitOMXParams(&def);

                    +        def.nPortIndex = kPortIndexOutput;

                    +

                    +        status_t err = mOMX->getParameter(

                    +        mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));

                    +        CHECK_EQ(err, OK);

                    +

                    +        OMX_VIDEO_PORTDEFINITIONTYPE *video_def = &def.format.video;

                    +        video_def->nStride = 4096;

                    +        LOGE("Updating video_def->nStride with new width %d", (int) video_def->nStride);

                    +        err = mOMX->setParameter(mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));

                    +

                    +        /*output port is not enabled for ducati codecs, delayed till we get buffers here */

                    +        enablePortAsync(kPortIndexOutput);

                    +        allocateBuffersOnPort(kPortIndexOutput);

                    +

                    +        //Make sure output port is reached to ENABLED state and thus mstate to EXECUTING

                    +        retrycount = 0;

                    +        while(mPortStatus[kPortIndexOutput] == ENABLING){

                    +            usleep(2000); // 2 mS

                    +            LOGD("(%d) Output port is ENABLING.. Waiting for port to be enabled.. %d",retrycount,mPortStatus[kPortIndexOutput] );

                    +            retrycount++;

                    +            CHECK(retrycount < 100);

                    +        }

                    +    }

                    +#endif

                    +}

                    +#endif

                    +

                     status_t OMXCodec::read(

                             MediaBuffer **buffer, const ReadOptions *options) {

                    +#if defined(TARGET_OMAP4) && defined(OMAP_ENHANCEMENT)

                         status_t wait_status = 0;

                    +#endif

                    +

                         *buffer = NULL;

                         Mutex::Autolock autoLock(mLock);

                    @@ -3230,6 +4833,18 @@ status_t OMXCodec::read(

                             return UNKNOWN_ERROR;

                         }

                    +#if defined(OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)

                    +    /*Stagefright port-reconfiguration logic is based on mOutputPortSettingsHaveChanged, which will be updated very late when port is reenabled */

                    +    /*Detect port-config event quickly so overlay buffers will be available upfront*/

                    +    if(!strcmp(mComponentName, "OMX.TI.DUCATI1.VIDEO.DECODER")){

                    +        if (mState == RECONFIGURING) {

                    +            mOutputPortSettingsHaveChanged = false;

                    +            mFilledBuffers.clear();

                    +            return INFO_FORMAT_CHANGED;

                    +        }

                    +    }

                    +#endif

                    +

                         bool seeking = false;

                         int64_t seekTimeUs;

                         ReadOptions::SeekMode seekMode;

                    @@ -3291,21 +4906,94 @@ status_t OMXCodec::read(

                             }

                             while (mSeekTimeUs >= 0) {

                    -            wait_status = mBufferFilled.waitRelative(mLock, 3000000000);

                    +#if defined(TARGET_OMAP4) && defined(OMAP_ENHANCEMENT)

                    +            wait_status = (mNSecsToWait == 0) ? mBufferFilled.wait(mLock) : mBufferFilled.waitRelative(mLock, mNSecsToWait);

                                 if (wait_status) {

                                     LOGE("Timed out waiting for the buffer! Line %d", __LINE__);

                                     return UNKNOWN_ERROR;

                                 }

                    +#else

                    +            mBufferFilled.wait(mLock);

                    +#endif

                             }

                         }

                    -    while (mState != ERROR && !mNoMoreOutputData && mFilledBuffers.empty()) {

                    -        wait_status = mBufferFilled.waitRelative(mLock, 3000000000);

                    +#ifdef OMAP_ENHANCEMENT

                    +    bool wasPaused = false;

                    +    if (mPaused) {

                    +        wasPaused = mPaused;

                    +        // We are resuming from the pause state. resetting the pause flag

                    +        mPaused = false;

                    +            /*Initiate the buffer flow on input port once again

                    +             * This is required to avoid starvation on I/P port if the

                    +             * previous empty_buffer_done calls are returned without

                    +             * initiating empty_buffer due to mpause was asserted.

                    +             * This needs to be done before waiting for the output buffer fill

                    +             * to avoid the deadlock

                    +             */

                    +            if (mState == EXECUTING) {

                    +                drainInputBuffers();

                    +            }

                    +    }

                    +#endif

                    +

                    +#if defined(TARGET_OMAP4) && defined(OMAP_ENHANCEMENT)

                    +    //only for OMAP4 Video decoder we shall check the buffers which are not with component

                    +    if (!strcmp("OMX.TI.DUCATI1.VIDEO.DECODER", mComponentName)) {

                    +        while (mState != RECONFIGURING && mState != ERROR && !mNoMoreOutputData && mFilledBuffers.empty()) {

                    +            CODEC_LOGV("READ LOCKED BUFFER QUEUE EMPTY FLAG : %d",mFilledBuffers.empty());

                    +            if (mState == EXECUTING && wasPaused) {

                    +                fillOutputBuffers();

                    +            }

                    +

                    +#if defined (NPA_BUFFERS)

                    +            if (mQuirks & OMXCodec::kThumbnailMode) {

                    +                if(mNumberOfNPABuffersSent){

                    +                    /*wait if atleast one filledbuffer is sent in NPA mode*/

                    +                    wait_status = (mNSecsToWait == 0) ? mBufferFilled.wait(mLock) : mBufferFilled.waitRelative(mLock, mNSecsToWait);

                    +                    if (wait_status) {

                    +                        LOGE("Timed out waiting for the buffer! Line %d", __LINE__);

                    +                        return UNKNOWN_ERROR;

                    +                    }

                    +                }

                    +            }else{

                    +                //Dont wait forever.

                    +                wait_status = (mNSecsToWait == 0) ? mBufferFilled.wait(mLock) : mBufferFilled.waitRelative(mLock, mNSecsToWait);

                    +                if (wait_status) {

                    +                    LOGE("Timed out waiting for the buffer! Line %d", __LINE__);

                    +                    return UNKNOWN_ERROR;

                    +                }

                    +            }

                    +#else

                    +            wait_status = (mNSecsToWait == 0) ? mBufferFilled.wait(mLock) : mBufferFilled.waitRelative(mLock, mNSecsToWait);

                    +            if (wait_status) {

                    +                LOGE("Timed out waiting for the buffer! Line %d", __LINE__);

                    +                return UNKNOWN_ERROR;

                    +            }

                    +#endif

                    +        }

                    +        /*see if we received a port reconfiguration */

                    +        if (mState == RECONFIGURING) {

                    +            mOutputPortSettingsHaveChanged = false;

                    +            mFilledBuffers.clear();

                    +            return INFO_FORMAT_CHANGED;

                    +        }

                    +    }

                    +    else {

                    +        while (mState != ERROR && !mNoMoreOutputData && mFilledBuffers.empty()) {

                    +            wait_status = (mNSecsToWait == 0) ? mBufferFilled.wait(mLock) : mBufferFilled.waitRelative(mLock, mNSecsToWait);

                             if (wait_status) {

                                 LOGE("Timed out waiting for the buffer! Line %d", __LINE__);

                                 return UNKNOWN_ERROR;

                             }

                         }

                    +    }

                    +

                    +#else

                    +    while (mState != ERROR && !mNoMoreOutputData && mFilledBuffers.empty()) {

                    +        mBufferFilled.wait(mLock);

                    +    }

                    +#endif

                         if (mState == ERROR) {

                             return UNKNOWN_ERROR;

                    @@ -3317,8 +5005,17 @@ status_t OMXCodec::read(

                         if (mOutputPortSettingsHaveChanged) {

                             mOutputPortSettingsHaveChanged = false;

                    -

                    +#if defined(TARGET_OMAP4) && defined(OMAP_ENHANCEMENT)

                    +        //for ducati codecs, to assert port reconfiguration immediately (so as to allocate overlay buffers upfront), we use mState as above.

                    +        //so, mOutputPortSettingsHaveChanged conditon check will result in redundant INFO_FORMAT_CHANGED event. Just proceed now.

                    +        //also, mOutputPortSettingsHaveChanged will be updated very late on port reenable, by the time overlay buffers are available and port enabled => just go ahead.

                    +        if (strcmp("OMX.TI.DUCATI1.VIDEO.DECODER", mComponentName)){

                    +            mFilledBuffers.clear();

                    +            return INFO_FORMAT_CHANGED;

                    +        }

                    +#else

                             return INFO_FORMAT_CHANGED;

                    +#endif

                         }

                         size_t index = *mFilledBuffers.begin();

                    @@ -3326,6 +5023,9 @@ status_t OMXCodec::read(

                         BufferInfo *info = &mPortBuffers[kPortIndexOutput].editItemAt(index);

                         info->mMediaBuffer->add_ref();

                    +#ifdef OMAP_ENHANCEMENT

                    +    info->mOwnedByPlayer = true;

                    +#endif

                         *buffer = info->mMediaBuffer;

                         return OK;

                    @@ -3339,9 +5039,26 @@ void OMXCodec::signalBufferReturned(MediaBuffer *buffer) {

                             BufferInfo *info = &buffers->editItemAt(i);

                             if (info->mMediaBuffer == buffer) {

                    +#ifdef OMAP_ENHANCEMENT

                    +            info->mOwnedByPlayer = false;

                    +            if(mState == RECONFIGURING) {

                    +                return;

                    +            }

                    +#endif

                                 CHECK_EQ(mPortStatus[kPortIndexOutput], ENABLED);

                    -            fillOutputBuffer(info);

                    -            return;

                    +#if defined(TARGET_OMAP4) && defined(OMAP_ENHANCEMENT)

                    +            if (!(*buffers)[i].mOwnedByComponent) {

                    +                fillOutputBuffer(info);

                    +                return;

                    +            }

                    +            else {

                    +                CODEC_LOGV("OP BUFFER ALREADY OWNED BY COMPONENT. RETURNING");

                    +                return;

                    +            }

                    +#else

                    +        fillOutputBuffer(info);

                    +        return;

                    +#endif

                             }

                         }

                    @@ -3441,8 +5158,23 @@ static const char *videoCompressionFormatString(OMX_VIDEO_CODINGTYPE type) {

                             "OMX_VIDEO_CodingRV",

                             "OMX_VIDEO_CodingAVC",

                             "OMX_VIDEO_CodingMJPEG",

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +        "OMX_VIDEO_CodingVP6",

                    +        "OMX_VIDEO_CodingVP7"

                    +#endif

                         };

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +

                    +    if (type == (OMX_VIDEO_CODINGTYPE) OMX_VIDEO_CodingVP6) {

                    +        return kNames[9];

                    +    }

                    +

                    +    if (type == (OMX_VIDEO_CODINGTYPE) OMX_VIDEO_CodingVP7) {

                    +        return kNames[10];

                    +    }

                    +#endif

                    +

                         size_t numNames = sizeof(kNames) / sizeof(kNames[0]);

                         if (type < 0 || (size_t)type >= numNames) {

                    @@ -3744,8 +5476,26 @@ void OMXCodec::initOutputFormat(const sp<MetaData> &inputFormat) {

                                             (mQuirks & kDecoderLiesAboutNumberOfChannels)

                                                 ? numChannels : params.nChannels);

                    +#ifndef OMAP_ENHANCEMENT

                                     // The codec-reported sampleRate is not reliable...

                                     mOutputFormat->setInt32(kKeySampleRate, sampleRate);

                    +#else

                    +                if ((OMX_U32)sampleRate != params.nSamplingRate) {

                    +                    LOGW("Codec outputs a different number of samplerate than "

                    +                            "the input stream contains (contains %d samplerate, "

                    +                            "codec outputs %ld samplerate).",

                    +                            sampleRate, params.nSamplingRate);

                    +                    mOutputFormat->setInt32(

                    +                            kKeySampleRate,

                    +                            (mQuirks & kDecoderNeedsPortReconfiguration)

                    +                            ? params.nSamplingRate : sampleRate);

                    +                }

                    +                else

                    +                {

                    +                  // The codec-reported sampleRate is not reliable...

                    +                    mOutputFormat->setInt32(kKeySampleRate, sampleRate);

                    +                }

                    +#endif

                                 } else if (audio_def->eEncoding == OMX_AUDIO_CodingAMR) {

                                     OMX_AUDIO_PARAM_AMRTYPE amr;

                                     InitOMXParams(&amr);

                    @@ -3803,6 +5553,20 @@ void OMXCodec::initOutputFormat(const sp<MetaData> &inputFormat) {

                                 } else if (video_def->eCompressionFormat == OMX_VIDEO_CodingAVC) {

                                     mOutputFormat->setCString(

                                             kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_AVC);

                    +#if defined(OMAP_ENHANCEMENT)

                    +#if defined(TARGET_OMAP4)

                    +            } else if (video_def->eCompressionFormat == (OMX_VIDEO_CODINGTYPE)OMX_VIDEO_CodingVP6) {

                    +                mOutputFormat->setCString(

                    +                        kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP6);

                    +            } else if (video_def->eCompressionFormat == (OMX_VIDEO_CODINGTYPE)OMX_VIDEO_CodingVP7) {

                    +                mOutputFormat->setCString(

                    +                        kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_VP7);

                    +#endif

                    +            }

                    +            else if (video_def->eCompressionFormat == OMX_VIDEO_CodingWMV)

                    +            {

                    +                mOutputFormat->setCString(kKeyMIMEType, MEDIA_MIMETYPE_VIDEO_WMV);

                    +#endif

                                 } else {

                                     CHECK(!"Unknown compression format.");

                                 }

                    @@ -3860,6 +5624,37 @@ void OMXCodec::initOutputFormat(const sp<MetaData> &inputFormat) {

                                 }

                                 mOutputFormat->setInt32(kKeyColorFormat, video_def->eColorFormat);

                    +

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +

                    +        /* for Non-Ducati HW codecs, padded with and height are updated with the

                    +        * video frame width and Height

                    +        */

                    +        mOutputFormat->setInt32(kKeyPaddedWidth, video_def->nFrameWidth);

                    +        mOutputFormat->setInt32(kKeyPaddedHeight, video_def->nFrameHeight);

                    +

                    +        /* Ducati codecs require padded output buffers.

                    +           Query proper size and update meta-data accordingly

                    +           which will be used later in renderer.

                    +           Note: 2D WxH in other OMX Get/Set parameter calls are seamless */

                    +        if (!strcmp("OMX.TI.DUCATI1.VIDEO.DECODER", mComponentName)) {

                    +

                    +            OMX_CONFIG_RECTTYPE tParamStruct;

                    +

                    +            InitOMXParams(&tParamStruct);

                    +            tParamStruct.nPortIndex = kPortIndexOutput;

                    +

                    +            err = mOMX->getParameter(

                    +                    mNode, (OMX_INDEXTYPE)OMX_TI_IndexParam2DBufferAllocDimension, &tParamStruct, sizeof(tParamStruct));

                    +

                    +            CHECK_EQ(err, OK);

                    +            mOutputFormat->setInt32(kKeyPaddedWidth, tParamStruct.nWidth);

                    +            mOutputFormat->setInt32(kKeyPaddedHeight, tParamStruct.nHeight);

                    +            LOGD("initOutputFormat WxH %dx%d Padded %dx%d ",

                    +                        (int) video_def->nFrameWidth, (int) video_def->nFrameHeight,

                    +                        (int) tParamStruct.nWidth, (int) tParamStruct.nHeight);

                    +        }

                    +#endif

                                 break;

                             }

                    @@ -3879,6 +5674,23 @@ status_t OMXCodec::pause() {

                         return OK;

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +int OMXCodec::getNumofOutputBuffers() {

                    +    OMX_PARAM_PORTDEFINITIONTYPE def;

                    +    InitOMXParams(&def);

                    +    def.nPortIndex = kPortIndexOutput;

                    +

                    +    status_t err = mOMX->getParameter(

                    +            mNode, OMX_IndexParamPortDefinition, &def, sizeof(def));

                    +    CHECK_EQ(err, OK);

                    +    CHECK_EQ(def.eDomain, OMX_PortDomainVideo);

                    +

                    +    LOGD("CodecRecommended O/P BufferCnt[%ld]", def.nBufferCountActual);

                    +

                    +    return (def.nBufferCountActual);

                    +}

                    +#endif

                    +

                     ////////////////////////////////////////////////////////////////////////////////

                     status_t QueryCodecs(

media/libstagefright/SampleTable.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -57,6 +57,11 @@ SampleTable::SampleTable(const sp<DataSource> &source)

                           mNumSyncSamples(0),

                           mSyncSamples(NULL),

                           mLastSyncSampleIndex(0),

                    +#ifdef OMAP_ENHANCEMENT

                    +      mTimeToSampleCountCtts(0),

                    +      mCttsSampleBuffer(NULL),

                    +      mTimeToSampleCtts(NULL),

                    +#endif

                           mSampleToChunkEntries(NULL) {

                         mSampleIterator = new SampleIterator(this);

                     }

                    @@ -73,6 +78,15 @@ SampleTable::~SampleTable() {

                         delete mSampleIterator;

                         mSampleIterator = NULL;

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +    delete[] mTimeToSampleCtts;

                    +    mTimeToSampleCtts = NULL;

                    +

                    +    delete[] mCttsSampleBuffer;

                    +    mCttsSampleBuffer = NULL;

                    +#endif

                    +

                     }

                     status_t SampleTable::setChunkOffsetParams(

                    @@ -227,6 +241,52 @@ status_t SampleTable::setSampleSizeParams(

                         return OK;

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +status_t SampleTable::setTimeToSampleParamsCtts(

                    +        off_t data_offset, size_t data_size) {

                    +    if (mTimeToSampleCtts != NULL || data_size < 8) {

                    +        return ERROR_MALFORMED;

                    +    }

                    +    uint8_t header[8];

                    +    uint32_t count_ctts,k=0;

                    +    if (mDataSource->readAt(

                    +                data_offset, header, sizeof(header)) < (ssize_t)sizeof(header)) {

                    +        return ERROR_IO;

                    +    }

                    +

                    +    if (U32_AT(header) != 0) {

                    +        // Expected version = 0, flags = 0.

                    +        return ERROR_MALFORMED;

                    +    }

                    +

                    +    mTimeToSampleCountCtts = U32_AT(&header[4]);

                    +

                    +    //find out the actual number of samples

                    +    mCttsSampleBuffer = new int32_t[mTimeToSampleCountCtts * 2];

                    +    size_t size = sizeof(int32_t) * mTimeToSampleCountCtts * 2;

                    +    if (mDataSource->readAt(

                    +                data_offset + 8, mCttsSampleBuffer, size) < (ssize_t)size) {

                    +        return ERROR_IO;

                    +    }

                    +

                    +    uint32_t countsamples = 0;

                    +    for(uint32_t i=0 ; i < mTimeToSampleCountCtts * 2; i+=2)

                    +        countsamples += ntohl(mCttsSampleBuffer[i]);

                    +

                    +    mTimeToSampleCtts = new int32_t[countsamples];

                    +

                    +    for (uint32_t i = 0; i < mTimeToSampleCountCtts * 2; i++) {

                    +        count_ctts = ntohl(mCttsSampleBuffer[i++]);

                    +        for(uint32_t j = 0;j < count_ctts ;j++){

                    +           mTimeToSampleCtts[k] = ntohl(mCttsSampleBuffer[i]);

                    +           LOGV("for loop ctts samples %d %d %d",mTimeToSampleCountCtts,mTimeToSampleCtts[k],k);

                    +           k++;

                    +        }

                    +    }

                    +    return OK;

                    +}

                    +#endif

                    +

                     status_t SampleTable::setTimeToSampleParams(

                             off_t data_offset, size_t data_size) {

                         if (mTimeToSample != NULL || data_size < 8) {

                    @@ -421,7 +481,16 @@ status_t SampleTable::findSyncSampleNear(

                         }

                         --left;

                    +#ifdef OMAP_ENHANCEMENT

                    +    /*This variable will be initialized to 1, so in case the stss table

                    +     *has 0 elements it will take by default frame 0. Frame 0 is supposed

                    +     * to be an I frame every time. When stss is zero mNumSyncSamples

                    +     * will be zero too, so the while loop will be skipped.

                    +     * */

                    +    uint32_t x=1;

                    +#else

                         uint32_t x;

                    +#endif

                         if (mDataSource->readAt(

                                     mSyncSampleOffset + 8 + left * 4, &x, 4) != 4) {

                             return ERROR_IO;

media/libstagefright/StagefrightMediaScanner.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -43,6 +43,9 @@ static bool FileHasAcceptableExtension(const char *extension) {

                             ".mpeg", ".ogg", ".mid", ".smf", ".imy", ".wma", ".aac",

                             ".wav", ".amr", ".midi", ".xmf", ".rtttl", ".rtx", ".ota",

                             ".mkv", ".mka", ".webm", ".ts", ".flac"

                    +#if defined(OMAP_ENHANCEMENT)

                    +        ,".wmv", ".asf"

                    +#endif

                         };

                         static const size_t kNumValidExtensions =

                             sizeof(kValidExtensions) / sizeof(kValidExtensions[0]);

media/libstagefright/StagefrightMetadataRetriever.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -28,8 +28,16 @@

                     #include <media/stagefright/MetaData.h>

                     #include <media/stagefright/OMXCodec.h>

                    +#if defined (TARGET_OMAP4) && defined (OMAP_ENHANCEMENT)

                    +#include <OMX_TI_IVCommon.h>

                    +#endif

                    +

                     namespace android {

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +extern void updateMetaData(sp<MetaData> meta_track);

                    +#endif

                    +

                     StagefrightMetadataRetriever::StagefrightMetadataRetriever()

                         : mParsedMetaData(false),

                           mAlbumArt(NULL) {

                    @@ -49,7 +57,11 @@ StagefrightMetadataRetriever::~StagefrightMetadataRetriever() {

                     }

                     status_t StagefrightMetadataRetriever::setDataSource(const char *uri) {

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    LOGD("setDataSource(%s)", uri);

                    +#else

                         LOGV("setDataSource(%s)", uri);

                    +#endif

                         mParsedMetaData = false;

                         mMetaData.clear();

                    @@ -112,6 +124,24 @@ static VideoFrame *extractVideoFrameWithCodecFlags(

                             uint32_t flags,

                             int64_t frameTimeUs,

                             int seekMode) {

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +    flags |= OMXCodec::kPreferThumbnailMode;

                    +#ifdef TARGET_OMAP4

                    +

                    +    int32_t isInterlaced = false;

                    +

                    +    //Call config parser to update profile,level,interlaced,reference frame data

                    +    updateMetaData(trackMeta);

                    +

                    +    trackMeta->findInt32(kKeyVideoInterlaced, &isInterlaced);

                    +

                    +    if(isInterlaced)

                    +    {

                    +      flags |= OMXCodec::kPreferInterlacedOutputContent;

                    +    }

                    +#endif

                    +#endif

                         sp<MediaSource> decoder =

                             OMXCodec::Create(

                                     client->interface(), source->getFormat(), false, source,

                    @@ -157,7 +187,18 @@ static VideoFrame *extractVideoFrameWithCodecFlags(

                                 buffer->release();

                                 buffer = NULL;

                             }

                    +

                             err = decoder->read(&buffer, &options);

                    +#ifdef OMAP_ENHANCEMENT

                    +        if(err == INFO_FORMAT_CHANGED)

                    +        {

                    +            int32_t w1,h1;

                    +            decoder->getFormat()->findInt32(kKeyWidth, &w1);

                    +            decoder->getFormat()->findInt32(kKeyHeight, &h1);

                    +            LOGD("Got portreconfig event. New WxH %dx%d. wait 5mS for port to be enabled",w1,h1);

                    +            usleep(5000); //sleep 5mS for port disable-enable to complete

                    +        }

                    +#endif

                             options.clearSeekTo();

                         } while (err == INFO_FORMAT_CHANGED

                                  || (buffer != NULL && buffer->range_length() == 0));

                    @@ -211,6 +252,77 @@ static VideoFrame *extractVideoFrameWithCodecFlags(

                         }

                         VideoFrame *frame = new VideoFrame;

                    +

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    int32_t srcFormat;

                    +    CHECK(meta->findInt32(kKeyColorFormat, &srcFormat));

                    +

                    +    int32_t format;

                    +    const char *component;

                    +

                    +    //cache the display width and height

                    +    int32_t displayWidth, displayHeight;

                    +    displayWidth = width;

                    +    displayHeight = height;

                    +

                    +    //update width & height with the buffer width&height

                    +    if(!(meta->findInt32(kKeyPaddedWidth, &width))) {

                    +        CHECK(meta->findInt32(kKeyWidth, &width));

                    +    }

                    +    if(!(meta->findInt32(kKeyPaddedHeight, &height))) {

                    +        CHECK(meta->findInt32(kKeyHeight, &height));

                    +    }

                    +    LOGD("VideoFrame WxH %dx%d", displayWidth, displayHeight);

                    +

                    +    if(((OMX_COLOR_FORMATTYPE)srcFormat == OMX_COLOR_FormatYUV420PackedSemiPlanar) ||

                    +       ((OMX_COLOR_FORMATTYPE)srcFormat == OMX_TI_COLOR_FormatYUV420PackedSemiPlanar_Sequential_TopBottom)){

                    +        frame->mWidth = displayWidth;

                    +        frame->mHeight = displayHeight;

                    +        frame->mDisplayWidth = displayWidth;

                    +        frame->mDisplayHeight = displayHeight;

                    +        frame->mSize = displayWidth * displayHeight * 2;

                    +        frame->mData = new uint8_t[frame->mSize];

                    +    frame->mRotationAngle = rotationAngle;

                    +    }else {

                    +        frame->mWidth = width;

                    +        frame->mHeight = height;

                    +        frame->mDisplayWidth = width;

                    +        frame->mDisplayHeight = height;

                    +        frame->mSize = width * height * 2;

                    +        frame->mData = new uint8_t[frame->mSize];

                    +    frame->mRotationAngle = rotationAngle;

                    +    }

                    +

                    +    if(((OMX_COLOR_FORMATTYPE)srcFormat == OMX_COLOR_FormatYUV420PackedSemiPlanar) ||

                    +       ((OMX_COLOR_FORMATTYPE)srcFormat == OMX_TI_COLOR_FormatYUV420PackedSemiPlanar_Sequential_TopBottom)){

                    +

                    +        ColorConverter converter(

                    +                (OMX_COLOR_FORMATTYPE)srcFormat, OMX_COLOR_Format16bitRGB565);

                    +

                    +        CHECK(converter.isValid());

                    +

                    +        converter.convert(

                    +                width, height,

                    +                (const uint8_t *)buffer->data() + buffer->range_offset(),

                    +                0, //1D buffer in 1.16 Ducati rls. If 2D buffer -> 4096 stride should be used

                    +                frame->mData, displayWidth * 2,

                    +                displayWidth,displayHeight,buffer->range_offset(),isInterlaced);

                    +    }

                    +    else{

                    +

                    +        ColorConverter converter(

                    +                (OMX_COLOR_FORMATTYPE)srcFormat, OMX_COLOR_Format16bitRGB565);

                    +

                    +        CHECK(converter.isValid());

                    +

                    +        converter.convert(

                    +                width, height,

                    +                (const uint8_t *)buffer->data() + buffer->range_offset(),

                    +                0,

                    +                frame->mData, width * 2);

                    +    }

                    +

                    +#else

                         frame->mWidth = width;

                         frame->mHeight = height;

                         frame->mDisplayWidth = width;

                    @@ -231,6 +343,7 @@ static VideoFrame *extractVideoFrameWithCodecFlags(

                                 (const uint8_t *)buffer->data() + buffer->range_offset(),

                                 0,

                                 frame->mData, width * 2);

                    +#endif

                         buffer->release();

                         buffer = NULL;

media/libstagefright/TISEIMessagesParser.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -0,0 +1,560 @@

                    +/*

                    + * Copyright (C) Texas Instruments - http://www.ti.com/

                    + *

                    + * This library is free software; you can redistribute it and/or

                    + * modify it under the terms of the GNU Lesser General Public

                    + * License as published by the Free Software Foundation; either

                    + * version 2.1 of the License, or (at your option) any later version.

                    + *

                    + *

                    + * This library is distributed in the hope that it will be useful,

                    + * but WITHOUT ANY WARRANTY; without even the implied warranty of

                    + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

                    + * Lesser General Public License for more details.

                    + *

                    + *

                    + * You should have received a copy of the GNU Lesser General Public

                    + * License along with this library; if not, write to the Free Software

                    + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

                    + */

                    +

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +

                    +#define LOG_TAG "SEI_TI_Parser"

                    +#include "include/TISEIMessagesParser.h"

                    +#include <utils/Log.h>

                    +

                    +#include <media/stagefright/MetaData.h>

                    +#include <media/stagefright/MediaDebug.h>

                    +#include <media/stagefright/Utils.h>

                    +

                    +#define MP4_INVALID_VOL_PARAM -1

                    +#define STEREO_VIDEO_INFO_TYPE 0x15

                    +#define FRAME_PACKING_ARRANGEMENT_TYPE 0x2D

                    +// To account for payloadtype and payloadsize bytes

                    +#define PAYLOAD_HEADER_SIZE 2

                    +

                    +#define PV_CLZ(A,B) while (((B) & 0x8000) == 0) {(B) <<=1; A++;}

                    +

                    +static const uint32_t mask[33] =

                    +{

                    +    0x00000000, 0x00000001, 0x00000003, 0x00000007,

                    +    0x0000000f, 0x0000001f, 0x0000003f, 0x0000007f,

                    +    0x000000ff, 0x000001ff, 0x000003ff, 0x000007ff,

                    +    0x00000fff, 0x00001fff, 0x00003fff, 0x00007fff,

                    +    0x0000ffff, 0x0001ffff, 0x0003ffff, 0x0007ffff,

                    +    0x000fffff, 0x001fffff, 0x003fffff, 0x007fffff,

                    +    0x00ffffff, 0x01ffffff, 0x03ffffff, 0x07ffffff,

                    +    0x0fffffff, 0x1fffffff, 0x3fffffff, 0x7fffffff,

                    +    0xffffffff

                    +};

                    +

                    +typedef struct

                    +{

                    +    uint8_t *data;

                    +    uint32_t numBytes;

                    +    uint32_t bytePos;

                    +    uint32_t bitBuf;

                    +    uint32_t dataBitPos;

                    +    uint32_t  bitPos;

                    +} mp4StreamType;

                    +

                    +/*------------------------------------------------------------------------------------

                    +    sStereo_video_info

                    +    This structure contains the stereo video information SEI msg elements

                    +   -----------------------------------------------------------------------------------*/

                    +typedef struct sei_stereo_video_info {

                    +   uint32_t field_views_flag;                                                  //!< u(1)

                    +   uint32_t top_field_is_left_view_flag;                                //!< u(1)

                    +   uint32_t current_frame_is_left_view_flag;                       //!< u(1)

                    +   uint32_t next_frame_is_second_view_flag;                     //!< u(1)

                    +   uint32_t left_view_self_contained_flag;                           //!< u(1)

                    +   uint32_t right_view_self_contained_flag;                         //!< u(1)

                    +}sStereo_video_info;

                    +

                    +/*------------------------------------------------------------------------------------

                    +    sframe_packing_arrangement

                    +    This structure contains the frame packing arrangement info for SEI msg elements

                    +   -----------------------------------------------------------------------------------*/

                    +typedef struct sei_frame_packing_arrangement {

                    +   uint32_t frame_packing_arrangement_id;                                                    //!< ue(v)

                    +   uint32_t frame_packing_arrangement_cancel_flag;                                    //!< u(1)

                    +   uint32_t frame_packing_arrangement_type;                                               //!< u(7)

                    +   uint32_t quincunx_sampling_flag;                                                                //!< u(1)

                    +   uint32_t content_interpretation_type;                                                          //!< u(6)

                    +   uint32_t spatial_flipping_flag;                                                                      //!< u(1)

                    +   uint32_t frame0_flipped_flag;                                                                      //!< u(1)

                    +   uint32_t field_views_flag;                                                                             //!< u(1)

                    +   uint32_t current_frame_is_frame0_flag;                                                     //!< u(7)

                    +   uint32_t frame0_self_contained_flag;                                                         //!< u(1)

                    +   uint32_t frame1_self_contained_flag;                                                         //!< u(1)

                    +   uint32_t frame0_grid_position_x;                                                                //!< u(4)

                    +   uint32_t frame0_grid_position_y;                                                                //!< u(4)

                    +   uint32_t frame1_grid_position_x;                                                                //!< u(4)

                    +   uint32_t frame1_grid_position_y;                                                                //!< u(4)

                    +   uint32_t frame_packing_arrangement_reserved_byte;                             //!< u(8)

                    +   uint32_t frame_packing_arrangement_repetition_period;                        //!< ue(v)

                    +   uint32_t frame_packing_arrangement_extension_flag;                            //!< u(1)

                    +}sframe_packing_arrangement;

                    +

                    +/*------------------------------------------------------------------------------------

                    +    sframe_packing_arrangement_type

                    +    This enum contains the frame packing arrangement type that will be passed to the display driver

                    +   -----------------------------------------------------------------------------------*/

                    +typedef enum {

                    +   checkerboard = 0,

                    +   column = 1,

                    +   row = 2,

                    +   side_by_side = 3,

                    +   top_bottom = 4,

                    +   temporal = 5,

                    +}sframe_packing_arrangement_type;

                    +

                    +using namespace android;

                    +

                    +int16_t ShowBits(

                    +    mp4StreamType *pStream,           /* Input Stream */

                    +    uint8_t ucNBits,          /* nr of bits to read */

                    +    uint32_t *pulOutData      /* output target */

                    +)

                    +{

                    +    uint8_t *bits;

                    +    uint32_t dataBitPos = pStream->dataBitPos;

                    +    uint32_t bitPos = pStream->bitPos;

                    +    uint32_t dataBytePos;

                    +

                    +    uint i;

                    +

                    +    if (ucNBits > (32 - bitPos))    /* not enough bits */

                    +    {

                    +        dataBytePos = dataBitPos >> 3; /* Byte Aligned Position */

                    +        bitPos = dataBitPos & 7; /* update bit position */

                    +        if (dataBytePos > pStream->numBytes - 4)

                    +        {

                    +            pStream->bitBuf = 0;

                    +            for (i = 0;i < pStream->numBytes - dataBytePos;i++)

                    +            {

                    +                pStream->bitBuf |= pStream->data[dataBytePos+i];

                    +                pStream->bitBuf <<= 8;

                    +            }

                    +            pStream->bitBuf <<= 8 * (3 - i);

                    +        }

                    +        else

                    +        {

                    +            bits = &pStream->data[dataBytePos];

                    +            pStream->bitBuf = (bits[0] << 24) | (bits[1] << 16) | (bits[2] << 8) | bits[3];

                    +        }

                    +        pStream->bitPos = bitPos;

                    +    }

                    +

                    +    bitPos += ucNBits;

                    +

                    +    *pulOutData = (pStream->bitBuf >> (32 - bitPos)) & mask[(uint16_t)ucNBits];

                    +

                    +    return 0;

                    +}

                    +

                    +int16_t FlushBits(

                    +    mp4StreamType *pStream,           /* Input Stream */

                    +    uint8_t ucNBits                      /* number of bits to flush */

                    +)

                    +{

                    +    uint8_t *bits;

                    +    uint32_t dataBitPos = pStream->dataBitPos;

                    +    uint32_t bitPos = pStream->bitPos;

                    +    uint32_t dataBytePos;

                    +

                    +

                    +    if ((dataBitPos + ucNBits) > (uint32_t)(pStream->numBytes << 3))

                    +        return (-2); // Buffer over run

                    +

                    +    dataBitPos += ucNBits;

                    +    bitPos     += ucNBits;

                    +

                    +    if (bitPos > 32)

                    +    {

                    +        dataBytePos = dataBitPos >> 3;    /* Byte Aligned Position */

                    +        bitPos = dataBitPos & 7; /* update bit position */

                    +        bits = &pStream->data[dataBytePos];

                    +        pStream->bitBuf = (bits[0] << 24) | (bits[1] << 16) | (bits[2] << 8) | bits[3];

                    +    }

                    +

                    +    pStream->dataBitPos = dataBitPos;

                    +    pStream->bitPos     = bitPos;

                    +

                    +    return 0;

                    +}

                    +

                    +int16_t ReadBits(

                    +    mp4StreamType *pStream,           /* Input Stream */

                    +    uint8_t ucNBits,                     /* nr of bits to read */

                    +    uint32_t *pulOutData                 /* output target */

                    +)

                    +{

                    +    uint8_t *bits;

                    +    uint32_t dataBitPos = pStream->dataBitPos;

                    +    uint32_t bitPos = pStream->bitPos;

                    +    uint32_t dataBytePos;

                    +

                    +

                    +    if ((dataBitPos + ucNBits) > (pStream->numBytes << 3))

                    +    {

                    +        *pulOutData = 0;

                    +        return (-2); // Buffer over run

                    +    }

                    +

                    +    //  dataBitPos += ucNBits;

                    +

                    +    if (ucNBits > (32 - bitPos))    /* not enough bits */

                    +    {

                    +        dataBytePos = dataBitPos >> 3;    /* Byte Aligned Position */

                    +        bitPos = dataBitPos & 7; /* update bit position */

                    +        bits = &pStream->data[dataBytePos];

                    +        pStream->bitBuf = (bits[0] << 24) | (bits[1] << 16) | (bits[2] << 8) | bits[3];

                    +    }

                    +

                    +    pStream->dataBitPos += ucNBits;

                    +    pStream->bitPos      = (unsigned char)(bitPos + ucNBits);

                    +

                    +    *pulOutData = (pStream->bitBuf >> (32 - pStream->bitPos)) & mask[(uint16_t)ucNBits];

                    +

                    +    return 0;

                    +}

                    +

                    +void ue_v(mp4StreamType *psBits, uint32_t *codeNum)

                    +{

                    +    uint32_t temp;

                    +    uint tmp_cnt;

                    +    int32_t leading_zeros = 0;

                    +    ShowBits(psBits, 16, &temp);

                    +    tmp_cnt = temp  | 0x1;

                    +    PV_CLZ(leading_zeros, tmp_cnt)

                    +

                    +    if (leading_zeros < 8)

                    +    {

                    +        *codeNum = (temp >> (15 - (leading_zeros << 1))) - 1;

                    +        FlushBits(psBits, (leading_zeros << 1) + 1);

                    +    }

                    +    else

                    +    {

                    +        ReadBits(psBits, (leading_zeros << 1) + 1, &temp);

                    +        *codeNum = temp - 1;

                    +    }

                    +}

                    +

                    +/* Subclause D.1.22 */

                    +int16_t stereo_video_info(mp4StreamType *psBits, S3D_params &mS3Dparams)

                    +{

                    +    // SEI message detected, default configuration

                    +    mS3Dparams.active = true;

                    +    mS3Dparams.mode = S3D_MODE_ON;

                    +    mS3Dparams.fmt = S3D_FORMAT_OVERUNDER;

                    +    mS3Dparams.subsampling = S3D_SS_NONE;

                    +

                    +    int16_t status =0;

                    +    uint32_t temp;

                    +    sStereo_video_info* pStereo_video_info = (sStereo_video_info *)malloc(sizeof(sStereo_video_info));

                    +    ReadBits(psBits, 1, &temp);

                    +    pStereo_video_info->field_views_flag = temp;

                    +

                    +    if( pStereo_video_info->field_views_flag )

                    +    {

                    +        mS3Dparams.metadata = S3D_SEI_STEREO_INFO_INTERLACED;

                    +        ReadBits(psBits, 1, &temp);

                    +        pStereo_video_info->top_field_is_left_view_flag = temp;

                    +        if(pStereo_video_info->top_field_is_left_view_flag)

                    +                mS3Dparams.order = S3D_ORDER_LF;

                    +        else

                    +                mS3Dparams.order = S3D_ORDER_RF;

                    +    }

                    +    else

                    +    {

                    +        mS3Dparams.metadata = S3D_SEI_STEREO_INFO_PROGRESSIVE;

                    +        ReadBits(psBits, 1, &temp);

                    +        pStereo_video_info->current_frame_is_left_view_flag = temp;

                    +        if(pStereo_video_info->current_frame_is_left_view_flag)

                    +                mS3Dparams.order = S3D_ORDER_LF;

                    +        else

                    +                mS3Dparams.order = S3D_ORDER_RF;

                    +

                    +        ReadBits(psBits, 1, &temp);

                    +        pStereo_video_info->next_frame_is_second_view_flag = temp;

                    +    }

                    +

                    +    ReadBits(psBits, 1, &temp);

                    +    pStereo_video_info->left_view_self_contained_flag = temp;

                    +    ReadBits(psBits, 1, &temp);

                    +    pStereo_video_info->right_view_self_contained_flag = temp;

                    +

                    +    free(pStereo_video_info);

                    +    return status;

                    +}

                    +

                    +/* Subclause D.1.25 */

                    +int16_t frame_packing_arrangement(mp4StreamType *psBits, S3D_params &mS3Dparams, int32_t payloadSize)

                    +{

                    +    // SEI message detected, default configuration

                    +    mS3Dparams.active = true;

                    +    mS3Dparams.mode = S3D_MODE_ON;

                    +    mS3Dparams.subsampling = S3D_SS_NONE;

                    +    mS3Dparams.metadata = S3D_SEI_STEREO_FRAME_PACKING;

                    +

                    +    int status =0, bitsToFlush = 0;

                    +    uint32_t temp;

                    +    uint32_t bitsread_diff = psBits->dataBitPos;

                    +

                    +    sframe_packing_arrangement* pframe_packing_arrangement = (sframe_packing_arrangement *)malloc(sizeof(sframe_packing_arrangement));

                    +    // Get and pass frame_packing_arrangement_type

                    +    ue_v(psBits, &(pframe_packing_arrangement->frame_packing_arrangement_id));

                    +    ReadBits(psBits, 1, &temp);

                    +    pframe_packing_arrangement->frame_packing_arrangement_cancel_flag = temp;

                    +    if(!pframe_packing_arrangement->frame_packing_arrangement_cancel_flag)

                    +    {

                    +        ReadBits(psBits, 7, &temp);

                    +        pframe_packing_arrangement->frame_packing_arrangement_type = temp;

                    +        set_frame_packing_arrangement_type(pframe_packing_arrangement->frame_packing_arrangement_type, mS3Dparams.fmt, mS3Dparams.subsampling);

                    +

                    +        ReadBits(psBits, 1, &temp);

                    +        pframe_packing_arrangement->quincunx_sampling_flag= temp;

                    +        ReadBits(psBits, 6, &temp);

                    +        pframe_packing_arrangement->content_interpretation_type= temp;

                    +        if(pframe_packing_arrangement->content_interpretation_type)

                    +            mS3Dparams.order = S3D_ORDER_LF;

                    +        else

                    +            mS3Dparams.order = S3D_ORDER_RF;

                    +

                    +        ReadBits(psBits, 1, &temp);

                    +        pframe_packing_arrangement->spatial_flipping_flag= temp;

                    +        ReadBits(psBits, 1, &temp);

                    +        pframe_packing_arrangement->frame0_flipped_flag= temp;

                    +        ReadBits(psBits, 1, &temp);

                    +        pframe_packing_arrangement->field_views_flag= temp;

                    +        ReadBits(psBits, 1, &temp);

                    +        pframe_packing_arrangement->current_frame_is_frame0_flag = temp;

                    +        ReadBits(psBits, 1, &temp);

                    +        pframe_packing_arrangement->frame0_self_contained_flag= temp;

                    +        ReadBits(psBits, 1, &temp);

                    +        pframe_packing_arrangement->frame1_self_contained_flag= temp;

                    +

                    +        if(!pframe_packing_arrangement->quincunx_sampling_flag &&

                    +            pframe_packing_arrangement->content_interpretation_type != temporal)

                    +        {

                    +            ReadBits(psBits, 4, &temp);

                    +            pframe_packing_arrangement->frame0_grid_position_x= temp;

                    +            ReadBits(psBits, 4, &temp);

                    +            pframe_packing_arrangement->frame0_grid_position_y = temp;

                    +            ReadBits(psBits, 4, &temp);

                    +            pframe_packing_arrangement->frame1_grid_position_x= temp;

                    +            ReadBits(psBits, 4, &temp);

                    +            pframe_packing_arrangement->frame1_grid_position_y= temp;

                    +        }

                    +        ReadBits(psBits, 8, &temp);

                    +        pframe_packing_arrangement->frame_packing_arrangement_reserved_byte = temp;

                    +        ue_v(psBits, &(pframe_packing_arrangement->frame_packing_arrangement_repetition_period));

                    +    }

                    +

                    +    ReadBits(psBits, 1, &temp);

                    +    pframe_packing_arrangement->frame_packing_arrangement_extension_flag = temp;

                    +

                    +    // To account for trailling 0;

                    +    bitsread_diff= psBits->dataBitPos - bitsread_diff;

                    +    bitsToFlush = 8*payloadSize - bitsread_diff;

                    +    if(bitsToFlush > 0)

                    +        FlushBits(psBits, bitsToFlush);

                    +

                    +    free(pframe_packing_arrangement);

                    +    return status; // return 0 for success

                    +}

                    +

                    +// Annex D.1 SEI payload syntax

                    +int16_t sei_payload(mp4StreamType *psBits, int32_t payloadType, int32_t payloadSize, S3D_params &mS3Dparams)

                    +{

                    +    int16_t status = 0;

                    +    int i;

                    +    switch (payloadType)

                    +    {

                    +        case STEREO_VIDEO_INFO_TYPE:

                    +        /*     Stereo video Information SEI message          */

                    +            status = stereo_video_info(psBits, mS3Dparams);

                    +        break;

                    +        case FRAME_PACKING_ARRANGEMENT_TYPE:

                    +        /*      Frame packaging arrangement SEI message */

                    +            status = frame_packing_arrangement(psBits, mS3Dparams, payloadSize);

                    +        break;

                    +        default: //for case 0-20,22-44 and reserved sei messages

                    +        /* SEI messages reserved or not supported*/

                    +        LOGE("SEI messages reserved or not supported: 0x%x\n", payloadType);

                    +        for (i = 0; i < payloadSize; i++)

                    +        {

                    +            FlushBits(psBits, 8);

                    +        }

                    +        break;

                    +    }

                    +    return status; // return 0 for success

                    +}

                    +

                    +//ref subclause 7.3.2.3.1 SEI message syntax

                    +int16_t sei_message(mp4StreamType *psBits, /*int32_t *ff_byte, */ int32_t *last_payload_type_byte, int32_t *last_payload_size_byte, S3D_params &mS3Dparams)

                    +{

                    +    uint32_t temp;

                    +    int32_t payloadType, payloadSize;

                    +    int16_t status = 0;

                    +

                    +    payloadType = 0;

                    +    // Not needed as the output of the read function does not contain the

                    +    // emulation prevention bytes.

                    +    /*while(0xFF == ReadBits(psBits, 8, &temp)) {

                    +        *ff_byte = temp;

                    +        payloadType += 255;

                    +    }*/

                    +

                    +    ReadBits(psBits, 8, &temp);

                    +    *last_payload_type_byte = temp;

                    +    payloadType += *last_payload_type_byte;

                    +    LOGV("Value for payloadType = %d \n", payloadType);

                    +

                    +    payloadSize = 0;

                    +    // Not needed as the output of the read function does not contain the

                    +    // emulation prevention bytes.

                    +    /*while(0xFF == ReadBits(psBits, 8, &temp)) {

                    +        *ff_byte = temp;

                    +        payloadSize += 255;

                    +    }*/

                    +

                    +    ReadBits(psBits, 8, &temp);

                    +    *last_payload_size_byte = temp;

                    +    payloadSize += *last_payload_size_byte;

                    +    LOGV("Value for payloadSize = %d \n", payloadSize);

                    +

                    +    status = sei_payload(psBits, payloadType, payloadSize, mS3Dparams);

                    +

                    +    return status;

                    +}

                    +

                    +namespace android {

                    +

                    +static int got_packing = 0;

                    +/* ======================================================================== */

                    +/*  Function : sei_rbsp()                                                   */

                    +/*  Purpose  : parse SEI messages NAL unit (ref: subclause 7.3.2.3)         */

                    +/* ======================================================================== */

                    +int16_t sei_rbsp(uint8_t *buffer, int32_t length , S3D_params &mS3Dparams)

                    +{

                    +    int16_t status = 0;

                    +    int32_t last_payload_type_byte, last_payload_size_byte;

                    +    uint32_t temp;

                    +    int32_t NALSize = 0;

                    +

                    +    got_packing = 0;

                    +    mp4StreamType psBits;

                    +    psBits.data  = buffer;

                    +    psBits.numBytes = length;

                    +    psBits.bytePos = 0;

                    +    psBits.bitBuf = 0;

                    +    psBits.dataBitPos = 0;

                    +    psBits.bitPos = 32;

                    +

                    +    // Check if SEI NAL Unit

                    +    ReadBits(&psBits, 8, &temp);

                    +    if ((temp & 0x1F) != 6) return MP4_INVALID_VOL_PARAM;

                    +

                    +    //Account for NAL Unit type message

                    +    NALSize++;

                    +

                    +  /*---------------------------------------------------------------------------

                    +  *     Multiple SEI messages can be present in one SEI NAL. This do-while

                    +  *     loop processes one SEI message per iteration.

                    +  ----------------------------------------------------------------------------*/

                    +    do

                    +    {

                    +        status = 0;

                    +        if (!got_packing) {

                    +            status = sei_message(&psBits, &last_payload_type_byte, &last_payload_size_byte, mS3Dparams);

                    +        }

                    +        ShowBits(&psBits, 8, &temp);

                    +        NALSize += PAYLOAD_HEADER_SIZE + last_payload_size_byte;

                    +    }while(temp != 0x80 && NALSize < (length-1) ); // more_rbsp_data();  We do account for termination bit 0x80

                    +  // ignore the trailing bits rbsp_trailing_bits();

                    +  //assert( NALSize+1 == length );

                    +

                    +    return status;

                    +}

                    +

                    +/* ======================================================================== */

                    +/*  Function : AVCGetNALType()                                              */

                    +/*  Purpose  : Sniff NAL type from the bitstream                            */

                    +/* ======================================================================== */

                    +int32_t AVCGetNALType(uint8_t *bitstream, int size,int *nal_type, int *nal_ref_idc)

                    +{

                    +    int forbidden_zero_bit;

                    +    if (size > 0)

                    +    {

                    +        forbidden_zero_bit = bitstream[0] >> 7;

                    +        if (forbidden_zero_bit != 0)

                    +            return -1;

                    +        *nal_ref_idc = (bitstream[0] & 0x60) >> 5;

                    +        *nal_type = bitstream[0] & 0x1F;

                    +        return 0;

                    +    }

                    +

                    +    return -1;

                    +}

                    +

                    +void set_frame_packing_arrangement_type(uint32_t frame_packing_arrangement_type, uint32_t &format, uint32_t &subsampling)

                    +{

                    +

                    +    switch(frame_packing_arrangement_type)

                    +    {

                    +        case checkerboard:

                    +        {

                    +            LOGV("Frame packing: Checkerboard \n");

                    +            format = S3D_FORMAT_CHECKB;

                    +            break;

                    +        }

                    +        case column:

                    +        {

                    +            LOGV("Frame packing: col il \n");

                    +            format = S3D_FORMAT_COL_IL;

                    +            break;

                    +        }

                    +        case row:

                    +        {

                    +            LOGV("Frame packing: row il \n");

                    +            format = S3D_FORMAT_ROW_IL;

                    +            break;

                    +        }

                    +        case side_by_side:

                    +        {

                    +            LOGV("Frame packing: side_by_side \n");

                    +            format = S3D_FORMAT_SIDEBYSIDE;

                    +            subsampling = S3D_SS_HOR;

                    +            break;

                    +        }

                    +        case top_bottom:

                    +        {

                    +            LOGV("Frame packing: TOP/BOT \n");

                    +            format = S3D_FORMAT_OVERUNDER;

                    +            subsampling = S3D_SS_VERT;

                    +            break;

                    +        }

                    +        case temporal:

                    +        {

                    +            LOGV("Frame packing: Frame Seq \n");

                    +            format = S3D_FORMAT_FRM_SEQ;

                    +            break;

                    +        }

                    +        default:

                    +        {

                    +            LOGV("Frame packing: Default to top/bottom \n");

                    +            format = S3D_FORMAT_OVERUNDER;

                    +            break;

                    +        }

                    +    }

                    +    got_packing = 1;

                    +}

                    +

                    +}// namespace android

                    +

                    +

                    +#endif

                    +

media/libstagefright/TIVideoConfigParser.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -0,0 +1,596 @@

                    +/*

                    + * Copyright (C) Texas Instruments - http://www.ti.com/

                    + *

                    + * This library is free software; you can redistribute it and/or

                    + * modify it under the terms of the GNU Lesser General Public

                    + * License as published by the Free Software Foundation; either

                    + * version 2.1 of the License, or (at your option) any later version.

                    + *

                    + *

                    + * This library is distributed in the hope that it will be useful,

                    + * but WITHOUT ANY WARRANTY; without even the implied warranty of

                    + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

                    + * Lesser General Public License for more details.

                    + *

                    + *

                    + * You should have received a copy of the GNU Lesser General Public

                    + * License along with this library; if not, write to the Free Software

                    + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

                    + */

                    +

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +

                    +#define LOG_TAG "SF_TI_Parser"

                    +#include <utils/Log.h>

                    +//#define LOG_NDEBUG 0

                    +

                    +#include <media/stagefright/MetaData.h>

                    +#include <media/stagefright/MediaDebug.h>

                    +#include <media/stagefright/Utils.h>

                    +

                    +#define MP4_INVALID_VOL_PARAM               -1

                    +#define SHORT_HEADER_MODE                   -4

                    +

                    +#define VISUAL_OBJECT_SEQUENCE_START_CODE   0x01B0

                    +#define VISUAL_OBJECT_SEQUENCE_END_CODE     0x01B1

                    +#define VISUAL_OBJECT_START_CODE            0x01B5

                    +#define VO_START_CODE                       0x8

                    +#define VO_HEADER_LENGTH                    32

                    +#define VOL_START_CODE                      0x12

                    +#define VOL_START_CODE_LENGTH               28

                    +

                    +#define GROUP_START_CODE                    0x01B3

                    +#define GROUP_START_CODE_LENGTH             32

                    +

                    +#define VOP_ID_CODE_LENGTH                  5

                    +#define VOP_TEMP_REF_CODE_LENGTH            16

                    +

                    +#define USER_DATA_START_CODE                0x01B2

                    +#define USER_DATA_START_CODE_LENGTH         32

                    +

                    +#define SHORT_VIDEO_START_MARKER            0x20

                    +#define SHORT_VIDEO_START_MARKER_LENGTH     22

                    +

                    +

                    +namespace android {

                    +

                    +

                    +typedef struct __bit_buffer {

                    +    uint8_t * start;

                    +    size_t size;

                    +    uint8_t * current;

                    +    uint8_t read_bits;

                    +} bit_buffer;

                    +

                    +static void skip_bits(bit_buffer * bb, size_t nbits) {

                    +    bb->current = bb->current + ((nbits + bb->read_bits) / 8);

                    +    bb->read_bits = (uint8_t)((bb->read_bits + nbits) % 8);

                    +}

                    +

                    +static uint8_t get_bit(bit_buffer * bb) {

                    +    uint8_t ret;

                    +    ret = (*(bb->current) >> (7 - bb->read_bits)) & 0x1;

                    +    if (bb->read_bits == 7) {

                    +        bb->read_bits = 0;

                    +        bb->current++;

                    +    }

                    +    else {

                    +        bb->read_bits++;

                    +    }

                    +    return ret;

                    +}

                    +

                    +static uint32_t get_bits(bit_buffer * bb, size_t nbits) {

                    +    uint32_t i, ret;

                    +    ret = 0;

                    +    for (i = 0; i < nbits; i++) {

                    +        ret = (ret << 1) + get_bit(bb);

                    +    }

                    +    return ret;

                    +}

                    +

                    +static uint32_t exp_golomb_ue(bit_buffer * bb) {

                    +    uint8_t bit, significant_bits;

                    +    significant_bits = 0;

                    +    bit = get_bit(bb);

                    +    while (bit == 0) {

                    +        significant_bits++;

                    +        bit = get_bit(bb);

                    +    }

                    +    return (1 << significant_bits) + get_bits(bb, significant_bits) - 1;

                    +}

                    +

                    +static int32_t exp_golomb_se(bit_buffer * bb) {

                    +    int32_t ret;

                    +    ret = exp_golomb_ue(bb);

                    +    if ((ret & 0x1) == 0) {

                    +        return -(ret >> 1);

                    +    }

                    +    else {

                    +        return (ret + 1) >> 1;

                    +    }

                    +}

                    +

                    +static void parse_scaling_list(uint32_t size, bit_buffer * bb) {

                    +    uint32_t last_scale, next_scale, i;

                    +    int32_t delta_scale;

                    +    last_scale = 8;

                    +    next_scale = 8;

                    +    for (i = 0; i < size; i++) {

                    +        if (next_scale != 0) {

                    +            delta_scale = exp_golomb_se(bb);

                    +            next_scale = (last_scale + delta_scale + 256) % 256;

                    +        }

                    +        if (next_scale != 0) {

                    +            last_scale = next_scale;

                    +        }

                    +    }

                    +}

                    +

                    +void parse_sps(uint8_t * sps,size_t sps_size,uint8_t *aprofile,uint8_t *alevel,uint32_t *num_ref_frames,uint8_t *interlaced)

                    +{

                    +    bit_buffer bb;

                    +    uint32_t pic_order_cnt_type, width_in_mbs, height_in_map_units;

                    +    uint32_t i, size, left, right, top, bottom;

                    +    uint8_t frame_mbs_only_flag;

                    +    uint8_t profile, level;

                    +    uint32_t width,height;

                    +

                    +    bb.start = sps;

                    +    bb.size = sps_size;

                    +    bb.current = sps;

                    +    bb.read_bits = 0;

                    +

                    +    /* skip first byte, since we already know we're parsing a SPS */

                    +    skip_bits(&bb, 8);

                    +

                    +    /* get profile */

                    +    profile = (uint8_t) get_bits(&bb, 8);

                    +    LOGV("AVC Profile %d",profile);

                    +

                    +    /* skip 8 bits */

                    +    skip_bits(&bb, 8);

                    +

                    +    /* get level */

                    +    level = (uint8_t) get_bits(&bb, 8);

                    +    LOGV("AVC Level %d",level);

                    +

                    +    *aprofile = profile;

                    +    *alevel = level;

                    +

                    +    /* read sps id, first exp-golomb encoded value */

                    +    exp_golomb_ue(&bb);

                    +

                    +    if (profile == 100 || profile == 110 || profile == 122 || profile == 144) {

                    +        /* chroma format idx */

                    +        if (exp_golomb_ue(&bb) == 3) {

                    +            skip_bits(&bb, 1);

                    +        }

                    +        /* bit depth luma minus8 */

                    +        exp_golomb_ue(&bb);

                    +        /* bit depth chroma minus8 */

                    +        exp_golomb_ue(&bb);

                    +        /* Qpprime Y Zero Transform Bypass flag */

                    +        skip_bits(&bb, 1);

                    +        /* Seq Scaling Matrix Present Flag */

                    +        if (get_bit(&bb)) {

                    +            for (i = 0; i < 8; i++) {

                    +                /* Seq Scaling List Present Flag */

                    +                if (get_bit(&bb)) {

                    +                    parse_scaling_list(i < 6 ? 16 : 64, &bb);

                    +                }

                    +            }

                    +        }

                    +    }

                    +    /* log2_max_frame_num_minus4 */

                    +    exp_golomb_ue(&bb);

                    +    /* pic_order_cnt_type */

                    +    pic_order_cnt_type = exp_golomb_ue(&bb);

                    +    if (pic_order_cnt_type == 0) {

                    +        /* log2_max_pic_order_cnt_lsb_minus4 */

                    +        exp_golomb_ue(&bb);

                    +    }

                    +    else if (pic_order_cnt_type == 1) {

                    +        /* delta_pic_order_always_zero_flag */

                    +        skip_bits(&bb, 1);

                    +        /* offset_for_non_ref_pic */

                    +        exp_golomb_se(&bb);

                    +        /* offset_for_top_to_bottom_field */

                    +        exp_golomb_se(&bb);

                    +        size = exp_golomb_ue(&bb);

                    +        for (i = 0; i < size; i++) {

                    +            /* offset_for_ref_frame */

                    +            exp_golomb_se(&bb);

                    +        }

                    +    }

                    +

                    +    /* num_ref_frames */

                    +    *num_ref_frames = exp_golomb_ue(&bb);

                    +    LOGV("AVC No of Ref frames %d",*num_ref_frames);

                    +

                    +    /* gaps_in_frame_num_value_allowed_flag */

                    +    skip_bits(&bb, 1);

                    +    /* pic_width_in_mbs */

                    +    width_in_mbs = exp_golomb_ue(&bb) + 1;

                    +    /* pic_height_in_map_units */

                    +    height_in_map_units = exp_golomb_ue(&bb) + 1;

                    +    /* frame_mbs_only_flag */

                    +    frame_mbs_only_flag = get_bit(&bb);

                    +

                    +    LOGV("AVC frame_mbs_only_flag %d", frame_mbs_only_flag);

                    +

                    +    /* 0-interlaced. 1-progressive */

                    +    *interlaced = !frame_mbs_only_flag;

                    +

                    +    if (!frame_mbs_only_flag) {

                    +        /* mb_adaptive_frame_field */

                    +        skip_bits(&bb, 1);

                    +    }

                    +    /* direct_8x8_inference_flag */

                    +    skip_bits(&bb, 1);

                    +    /* frame_cropping */

                    +    left = right = top = bottom = 0;

                    +    if (get_bit(&bb)) {

                    +        left = exp_golomb_ue(&bb) * 2;

                    +        right = exp_golomb_ue(&bb) * 2;

                    +        top = exp_golomb_ue(&bb) * 2;

                    +        bottom = exp_golomb_ue(&bb) * 2;

                    +        if (!frame_mbs_only_flag) {

                    +            top *= 2;

                    +            bottom *= 2;

                    +        }

                    +    }

                    +

                    +    /* width */

                    +    width = width_in_mbs * 16 - (left + right);

                    +    /* height */

                    +    height = height_in_map_units * 16 - (top + bottom);

                    +    if (!frame_mbs_only_flag) {

                    +        height *= 2;

                    +    }

                    +}

                    +

                    +

                    +void ReadBits(bit_buffer *bb, int nbits, uint32_t* val)

                    +{

                    +    *val = get_bits(bb, nbits);

                    +}

                    +

                    +int16_t Search4VOLHeader(bit_buffer *psBits)

                    +{

                    +    uint32_t i;

                    +    int32_t count = 0;

                    +    int16_t status = -1;

                    +

                    +    uint32_t curr_state = 0;

                    +    bool found = false;

                    +

                    +     /* search 0x00 0x00 0x01 0x20 */

                    +

                    +     /* Byte alignment*/

                    +     while(psBits->read_bits)

                    +     {

                    +         ReadBits(psBits,1,&i);

                    +     }

                    +

                    +     do{

                    +        ReadBits(psBits,8,&i);

                    +        switch(curr_state)

                    +        {

                    +            case 0:

                    +                      if(i==0) curr_state = 1;      /* just got 00 */

                    +                          else curr_state = 0;

                    +                      break;

                    +            case 1:

                    +                      if(i==0) curr_state = 2;      /* Now 00. Got 00*/

                    +                      else curr_state = 0;

                    +                      break;

                    +            case 2:

                    +                      if(i==1) curr_state = 3;      /* Now 01. Got 00 00 */

                    +                      else if(i==0) curr_state = 2; /* Now 00. Got 00 00*/

                    +                      else curr_state = 0;

                    +                      break;

                    +            case 3:

                    +                      if(i==0x20) found = true;     /*Now 20. Got 00 00 01*/

                    +                      else curr_state = 0;

                    +                      break;

                    +        };

                    +

                    +     }while((psBits->current < psBits->start + psBits->size)  && !found);

                    +

                    +     if(found)

                    +       status = 0;

                    +     else

                    +       status = -1;

                    +

                    +    return status;

                    +}

                    +

                    +int16_t parse_vol(uint8_t *vol,size_t vol_size,uint8_t *aprofile,uint8_t *alevel,uint32_t *num_ref_frames,uint8_t* interlaced)

                    +{

                    +    int16_t iErrorStat;

                    +    uint32_t codeword;

                    +    uint32_t time_increment_resolution, nbits_time_increment;

                    +    uint32_t i, j;

                    +

                    +    uint32_t display_width, display_height;

                    +    uint32_t width,height;

                    +

                    +    int32_t* profilelevel;

                    +

                    +

                    +    bit_buffer bb;

                    +    bb.start = vol;

                    +    bb.size = vol_size;

                    +    bb.current = vol;

                    +    bb.read_bits = 0;

                    +

                    +    bit_buffer *psBits = &bb;

                    +

                    +    uint32_t status =  0;

                    +

                    +    while(psBits->current <(psBits->start + psBits->size)){

                    +

                    +    /* detect VOL start code 00 00 01 20 */

                    +    uint32_t status = Search4VOLHeader(psBits);

                    +

                    +        uint32_t vol_id;

                    +

                    +        /* vol_id (4 bits) */

                    +        //ReadBits(psBits, 4, & vol_id);

                    +

                    +        // RandomAccessibleVOLFlag

                    +        ReadBits(psBits, 1, &codeword);

                    +

                    +        //Video Object Type Indication

                    +        ReadBits(psBits, 8, &codeword);

                    +        if (codeword != 1)

                    +        {

                    +            //return MP4_INVALID_VOL_PARAM; //TI supports this feature

                    +        }

                    +

                    +        // is_object_layer_identifier

                    +        ReadBits(psBits, 1, &codeword);

                    +

                    +        if (codeword)

                    +        {

                    +            ReadBits(psBits, 4, &codeword);

                    +            ReadBits(psBits, 3, &codeword);

                    +        }

                    +

                    +        // aspect ratio

                    +        ReadBits(psBits, 4, &codeword);

                    +

                    +        if (codeword == 0xF)

                    +        {

                    +            // Extended Parameter

                    +            /* width */

                    +            ReadBits(psBits, 8, &codeword);

                    +            /* height */

                    +            ReadBits(psBits, 8, &codeword);

                    +        }

                    +

                    +        ReadBits(psBits, 1, &codeword);

                    +

                    +        if (codeword)

                    +        {

                    +            ReadBits(psBits, 2, &codeword);

                    +            if (codeword != 1)

                    +            {

                    +                return MP4_INVALID_VOL_PARAM;

                    +            }

                    +

                    +            ReadBits(psBits, 1, &codeword);

                    +

                    +            if (!codeword)

                    +            {

                    +                //return MP4_INVALID_VOL_PARAM; //TI supports this feature

                    +            }

                    +

                    +            ReadBits(psBits, 1, &codeword);

                    +            if (codeword)   /* if (vbv_parameters) {}, page 36 */

                    +            {

                    +                ReadBits(psBits, 15, &codeword);

                    +                ReadBits(psBits, 1, &codeword);

                    +                if (codeword != 1)

                    +                {

                    +                    return MP4_INVALID_VOL_PARAM;

                    +                }

                    +

                    +                ReadBits(psBits, 15, &codeword);

                    +                ReadBits(psBits, 1, &codeword);

                    +                if (codeword != 1)

                    +                {

                    +                    return MP4_INVALID_VOL_PARAM;

                    +                }

                    +

                    +

                    +                ReadBits(psBits, 19, &codeword);

                    +                if (!(codeword & 0x8))

                    +                {

                    +                    return MP4_INVALID_VOL_PARAM;

                    +                }

                    +

                    +                ReadBits(psBits, 11, &codeword);

                    +                ReadBits(psBits, 1, &codeword);

                    +                if (codeword != 1)

                    +                {

                    +                    return MP4_INVALID_VOL_PARAM;

                    +                }

                    +

                    +                ReadBits(psBits, 15, &codeword);

                    +                ReadBits(psBits, 1, &codeword);

                    +                if (codeword != 1)

                    +                {

                    +                    return MP4_INVALID_VOL_PARAM;

                    +                }

                    +            }

                    +

                    +        }

                    +

                    +        ReadBits(psBits, 2, &codeword);

                    +

                    +        if (codeword != 0)

                    +        {

                    +            return MP4_INVALID_VOL_PARAM;

                    +        }

                    +

                    +        ReadBits(psBits, 1, &codeword);

                    +        if (codeword != 1)

                    +        {

                    +            return MP4_INVALID_VOL_PARAM;

                    +        }

                    +

                    +        ReadBits(psBits, 16, &codeword);

                    +        time_increment_resolution = codeword;

                    +

                    +

                    +        ReadBits(psBits, 1, &codeword);

                    +        if (codeword != 1)

                    +        {

                    +            return MP4_INVALID_VOL_PARAM;

                    +        }

                    +

                    +

                    +

                    +        ReadBits(psBits, 1, &codeword);

                    +

                    +        if (codeword && time_increment_resolution > 2)

                    +        {

                    +            i = time_increment_resolution - 1;

                    +            j = 1;

                    +            while (i >>= 1)

                    +            {

                    +                j++;

                    +            }

                    +            nbits_time_increment = j;

                    +

                    +            ReadBits(psBits, nbits_time_increment, &codeword);

                    +        }

                    +

                    +        ReadBits(psBits, 1, &codeword);

                    +        if (codeword != 1)

                    +        {

                    +            return MP4_INVALID_VOL_PARAM;

                    +        }

                    +

                    +        /* this should be 176 for QCIF */

                    +        ReadBits(psBits, 13, &codeword);

                    +        display_width = (uint32_t)codeword;

                    +        ReadBits(psBits, 1, &codeword);

                    +        if (codeword != 1)

                    +        {

                    +            return MP4_INVALID_VOL_PARAM;

                    +        }

                    +

                    +        /* this should be 144 for QCIF */

                    +        ReadBits(psBits, 13, &codeword);

                    +        display_height = (uint32_t)codeword;

                    +

                    +        width = (display_width + 15) & -16;

                    +        height = (display_height + 15) & -16;

                    +

                    +        /* marker */

                    +        ReadBits(psBits, 1, &codeword);

                    +

                    +        /* interlaced */

                    +        ReadBits(psBits, 1, &codeword);

                    +        LOGD("INTERLACE 0x%x",codeword);

                    +

                    +        if(codeword == 1)

                    +        {

                    +            *interlaced = (uint8_t) 1;

                    +        }

                    +        else

                    +        {

                    +            *interlaced = (uint8_t) 0;

                    +        }

                    +        return 0;

                    +

                    +    }

                    +

                    +    return 0;

                    +}

                    +

                    +void updateMetaData(sp<MetaData> meta_track)

                    +{

                    +    uint32_t type;

                    +    const void *data;

                    +    size_t size;

                    +

                    +    uint8_t profile,level,interlaced;

                    +    uint32_t num_ref_frames;

                    +

                    +    interlaced = 0;

                    +    profile = 0;

                    +    level = 0;

                    +    num_ref_frames = 0;

                    +

                    +    if ( meta_track->findData(kKeyESDS, &type, &data, &size)) {

                    +        LOGV("MPEG4 Header");

                    +        LOGV("size %d",size);

                    +        LOGV("type 0x%x", type);

                    +        LOGV("data 0x%x", data);

                    +

                    +        uint8_t *ptr = (uint8_t *)data;

                    +

                    +        parse_vol(ptr, size, &profile, &level, &num_ref_frames, &interlaced);

                    +

                    +        LOGV("MPEG4  Profile %d Level %d RefFrames %d Interlaced %d ", profile,level,num_ref_frames,interlaced);

                    +        meta_track->setInt32(kKeyVideoProfile, profile);

                    +        meta_track->setInt32(kKeyVideoLevel, level);

                    +        meta_track->setInt32(kKeyVideoInterlaced, interlaced);

                    +        meta_track->setInt32(kKeyNumRefFrames, num_ref_frames);

                    +

                    +

                    +    }

                    +    else if ( meta_track->findData(kKeyAVCC, &type, &data, &size)) {

                    +        LOGV("H264 Header");

                    +        LOGV("size %d",size);

                    +        LOGV("type 0x%x", type);

                    +        LOGV("data 0x%x", data);

                    +

                    +        const uint8_t *ptr = (const uint8_t *)data;

                    +

                    +        CHECK(size >= 7);

                    +        CHECK_EQ(ptr[0], 1);  // configurationVersion == 1

                    +

                    +        size_t numSeqParameterSets = ptr[5] & 31;

                    +

                    +        LOGV("numSeqParameterSets %d",numSeqParameterSets);

                    +

                    +        ptr += 6;

                    +        size -= 6;

                    +

                    +        for (size_t i = 0; i < numSeqParameterSets; ++i) {

                    +            CHECK(size >= 2);

                    +            size_t length = U16_AT(ptr);

                    +

                    +            ptr += 2;

                    +            size -= 2;

                    +

                    +            CHECK(size >= length);

                    +

                    +            parse_sps((uint8_t*)ptr, length, &profile, &level, &num_ref_frames, &interlaced);

                    +

                    +            LOGV("H264 Profile %d Level %d RefFrames %d Interlaced %d", profile,level,num_ref_frames,interlaced);

                    +            meta_track->setInt32(kKeyVideoProfile, profile);

                    +            meta_track->setInt32(kKeyVideoLevel, level);

                    +            meta_track->setInt32(kKeyNumRefFrames, num_ref_frames);

                    +            meta_track->setInt32(kKeyVideoInterlaced, interlaced);

                    +

                    +            ptr += length;

                    +            size -= length;

                    +        }

                    +

                    +    }

                    +

                    +    return;

                    +}

                    +

                    +

                    +}  // namespace android

                    +

                    +

                    +#endif

                    +

media/libstagefright/WAVExtractor.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -316,9 +316,16 @@ status_t WAVSource::read(

                         *out = NULL;

                         int64_t seekTimeUs;

                    +#ifdef OMAP_ENHANCEMENT

                    +    size_t bytesPerSample = mBitsPerSample >> 3;

                    +#endif

                         ReadOptions::SeekMode mode;

                         if (options != NULL && options->getSeekTo(&seekTimeUs, &mode)) {

                    +#ifdef OMAP_ENHANCEMENT

                    +        int64_t pos = (seekTimeUs * mSampleRate) / 1000000 * mNumChannels * bytesPerSample;

                    +#else

                             int64_t pos = (seekTimeUs * mSampleRate) / 1000000 * mNumChannels * 2;

                    +#endif

                             if (pos > mSize) {

                                 pos = mSize;

                             }

                    @@ -353,7 +360,11 @@ status_t WAVSource::read(

                             return ERROR_END_OF_STREAM;

                         }

                    +#ifdef OMAP_ENHANCEMENT

                    +    int64_t offsetPos = n;

                    +#else

                         mCurrentPos += n;

                    +#endif

                         buffer->set_range(0, n);

                    @@ -398,13 +409,18 @@ status_t WAVSource::read(

                             }

                         }

                    +

                    +#ifndef OMAP_ENHANCEMENT

                         size_t bytesPerSample = mBitsPerSample >> 3;

                    +#endif

                         buffer->meta_data()->setInt64(

                                 kKeyTime,

                                 1000000LL * (mCurrentPos - mOffset)

                                     / (mNumChannels * bytesPerSample) / mSampleRate);

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +    mCurrentPos += offsetPos;

                    +#endif

                         buffer->meta_data()->setInt32(kKeyIsSyncFrame, 1);

                         *out = buffer;

media/libstagefright/codecs/mp3dec/Android.mk

show inline notes
View file @ 1a6862f

            
                    @@ -48,6 +48,11 @@ LOCAL_C_INCLUDES := \

                             $(LOCAL_PATH)/src \

                             $(LOCAL_PATH)/include

                    +ifeq ($(OMAP_ENHANCEMENT),true)

                    +    LOCAL_C_INCLUDES += hardware/ti/omx/ducati/domx/system/omx_core/inc/

                    +endif

                    +

                    +

                     LOCAL_CFLAGS := \

                             -DOSCL_UNUSED_ARG=

media/libstagefright/colorconversion/Android.mk

show inline notes
View file @ 1a6862f

            
                    @@ -8,6 +8,10 @@ LOCAL_SRC_FILES:=                     \

                     LOCAL_C_INCLUDES := \

                             $(TOP)/frameworks/base/include/media/stagefright/openmax

                    +ifeq ($(TARGET_BOARD_PLATFORM),omap4)

                    +LOCAL_C_INCLUDES += hardware/ti/omx/ducati/domx/system/omx_core/inc

                    +endif

                    +

                     LOCAL_SHARED_LIBRARIES :=       \

                             libbinder               \

                             libmedia                \

                    @@ -17,6 +21,10 @@ LOCAL_SHARED_LIBRARIES :=       \

                             libsurfaceflinger_client\

                             libcamera_client

                    +ifeq ($(TARGET_BOARD_PLATFORM),omap4)

                    +LOCAL_CFLAGS += -DTARGET_OMAP4 -DARM_4K_PAGE_SIZE=4096

                    +endif

                    +

                     LOCAL_MODULE:= libstagefright_color_conversion

                     include $(BUILD_SHARED_LIBRARY)

media/libstagefright/colorconversion/ColorConverter.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -18,6 +18,10 @@

                     #include <media/stagefright/ColorConverter.h>

                     #include <media/stagefright/MediaDebug.h>

                    +#if defined (TARGET_OMAP4) && defined (OMAP_ENHANCEMENT)

                    +#include <OMX_TI_IVCommon.h>

                    +#endif

                    +

                     namespace android {

                     static const int OMX_QCOM_COLOR_FormatYVU420SemiPlanar = 0x7FA30C00;

                    @@ -50,6 +54,10 @@ bool ColorConverter::isValid() const {

                             case OMX_QCOM_COLOR_FormatYVU420SemiPlanar:

                             case OMX_COLOR_FormatYUV420SemiPlanar:

                             case QOMX_COLOR_FormatYUV420PackedSemiPlanar64x32Tile2m8ka:

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +        case OMX_COLOR_FormatYUV420PackedSemiPlanar:

                    +        case OMX_TI_COLOR_FormatYUV420PackedSemiPlanar_Sequential_TopBottom:

                    +#endif

                                 return true;

                             default:

                    @@ -57,10 +65,18 @@ bool ColorConverter::isValid() const {

                         }

                     }

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +void ColorConverter::convert(

                    +        size_t width, size_t height,

                    +        const void *srcBits, size_t srcSkip,

                    +        void *dstBits, size_t dstSkip,

                    +        size_t dwidth, size_t dheight, size_t nOffset, bool interlaced) {

                    +#else

                     void ColorConverter::convert(

                             size_t width, size_t height,

                             const void *srcBits, size_t srcSkip,

                             void *dstBits, size_t dstSkip) {

                    +#endif

                         CHECK_EQ(mDstFormat, OMX_COLOR_Format16bitRGB565);

                         switch (mSrcFormat) {

                    @@ -88,7 +104,13 @@ void ColorConverter::convert(

                                 convertNV12Tile(

                                         width, height, srcBits, srcSkip, dstBits, dstSkip);

                                 break;

                    -

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +        case OMX_COLOR_FormatYUV420PackedSemiPlanar:

                    +        case OMX_TI_COLOR_FormatYUV420PackedSemiPlanar_Sequential_TopBottom:

                    +            convertYUV420PackedSemiPlanar(

                    +                    width, height, dwidth, dheight,nOffset,srcBits, srcSkip, dstBits, dstSkip, interlaced);

                    +            break;

                    +#endif

                             default:

                             {

                                 CHECK(!"Should not be here. Unknown color conversion.");

                    @@ -359,6 +381,93 @@ void ColorConverter::convertYUV420SemiPlanar(

                         }

                     }

                    +

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +void ColorConverter::convertYUV420PackedSemiPlanar(

                    +        size_t width, size_t height,

                    +        size_t displaywidth, size_t displayheight, size_t nOffset,

                    +        const void *srcBits, size_t srcSkip,

                    +        void *dstBits, size_t dstSkip, bool interlaced) {

                    +

                    +    CHECK((dstSkip & 3) == 0);

                    +

                    +    size_t stride = width;

                    +

                    +    if(srcSkip)

                    +        stride = srcSkip;

                    +

                    +    uint8_t *kAdjustedClip = initClip();

                    +

                    +    uint32_t *dst_ptr = (uint32_t *)dstBits;

                    +    const uint8_t *src_y = (const uint8_t *)srcBits;

                    +

                    +    uint32_t offx = nOffset  % stride;

                    +    uint32_t offy = nOffset / stride;

                    +

                    +

                    +    const uint8_t *src_u = (const uint8_t *)(src_y-nOffset) + (stride * height);

                    +    src_u += ( ( stride * (offy/2) ) + offx );

                    +

                    +    const uint8_t *src_v = src_u + 1;

                    +

                    +    for (size_t y = 0; y < displayheight; ++y) {

                    +        for (size_t x = 0; x < displaywidth; x += 2) {

                    +

                    +            signed y1 = (signed)src_y[x] - 16;    //Y pixel

                    +            signed y2 = (signed)src_y[x + 1] - 16; //2nd Y pixel

                    +

                    +            signed u = (signed)src_u[x & ~1] - 128;   //U component

                    +            signed v = (signed)src_u[(x & ~1) + 1] - 128; //V component

                    +

                    +            signed u_b = u * 517;

                    +            signed u_g = -u * 100;

                    +            signed v_g = -v * 208;

                    +            signed v_r = v * 409;

                    +

                    +            signed tmp1 = y1 * 298;

                    +            signed b1 = (tmp1 + u_b) / 256;

                    +            signed g1 = (tmp1 + v_g + u_g) / 256;

                    +            signed r1 = (tmp1 + v_r) / 256;

                    +

                    +            signed tmp2 = y2 * 298;

                    +            signed b2 = (tmp2 + u_b) / 256;

                    +            signed g2 = (tmp2 + v_g + u_g) / 256;

                    +            signed r2 = (tmp2 + v_r) / 256;

                    +

                    +            uint32_t rgb1 =

                    +                ((kAdjustedClip[r1] >> 3) << 11)

                    +                | ((kAdjustedClip[g1] >> 2) << 5)

                    +                | (kAdjustedClip[b1] >> 3);

                    +

                    +            uint32_t rgb2 =

                    +                ((kAdjustedClip[r2] >> 3) << 11)

                    +                | ((kAdjustedClip[g2] >> 2) << 5)

                    +                | (kAdjustedClip[b2] >> 3);

                    +

                    +            dst_ptr[x / 2] = (rgb2 << 16) | rgb1;

                    +        }

                    +

                    +        if(!interlaced){

                    +            src_y += stride; //increment Y-pixel line

                    +            if(y&1){

                    +              src_u += stride; //increment U-V line

                    +            }

                    +        }

                    +        else{

                    +            /* Interlaced stream. Will have Sequential Top Bottom content*/

                    +            /* Just extrapolate first half contnents from Y,UV planes */

                    +            if(y&1){

                    +                src_y += stride; //increment Y-pixel line, once for two lines

                    +                if((y/2)&1){

                    +                  src_u += stride; //increment U-V line, once for four lines

                    +                }

                    +            }

                    +        }

                    +        dst_ptr += dstSkip / 4;

                    +    }

                    +}

                    +#endif

                    +

                     uint8_t *ColorConverter::initClip() {

                         static const signed kClipMin = -278;

                         static const signed kClipMax = 535;

media/libstagefright/colorconversion/SoftwareRenderer.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -108,4 +108,12 @@ void SoftwareRenderer::render(

                         mIndex = 1 - mIndex;

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +Vector< sp<IMemory> > SoftwareRenderer::getBuffers(){

                    +    // Not Implemented

                    +    Vector< sp<IMemory> > mDummy;

                    +    return mDummy;

                    +}

                    +#endif

                    +

                     }  // namespace android

media/libstagefright/id3/Android.mk

show inline notes
View file @ 1a6862f

            
                    @@ -4,6 +4,9 @@ include $(CLEAR_VARS)

                     LOCAL_SRC_FILES := \

                       ID3.cpp

                    +LOCAL_C_INCLUDES:= \

                    +        $(TOP)/frameworks/base/include/media/stagefright/openmax

                    +

                     LOCAL_MODULE := libstagefright_id3

                     include $(BUILD_STATIC_LIBRARY)

media/libstagefright/include/ASFExtractor.h

show inline notes
View file @ 1a6862f

            
                    @@ -0,0 +1,93 @@

                    +/*

                    + *****************************************************************************

                    + *

                    + *                                Android

                    + *                  ITTIAM SYSTEMS PVT LTD, BANGALORE

                    + *                           COPYRIGHT(C) 2010-20

                    + *

                    + *  This program  is  proprietary to  Ittiam  Systems  Private  Limited  and

                    + *  is protected under Indian  Copyright Law as an unpublished work. Its use

                    + *  and  disclosure  is  limited by  the terms  and  conditions of a license

                    + *  agreement. It may not be copied or otherwise  reproduced or disclosed to

                    + *  persons outside the licensee's organization except in accordance with the

                    + *  terms  and  conditions   of  such  an  agreement.  All  copies  and

                    + *  reproductions shall be the property of Ittiam Systems Private Limited and

                    + *  must bear this notice in its entirety.

                    + *

                    + *****************************************************************************

                    + */

                    +/**

                    + *****************************************************************************

                    + *

                    + *  @file     ASFExtractor.h

                    + *

                    + *  @brief    This file contains definition of ASFExtractor class

                    + *

                    + *****************************************************************************

                    + */

                    +

                    +#ifndef ITTIAM_ASF_EXTRACTOR_H_

                    +

                    +#define ITTIAM_ASF_EXTRACTOR_H_

                    +

                    +#include <media/stagefright/MediaExtractor.h>

                    +#include <utils/Vector.h>

                    +

                    +namespace android {

                    +

                    +struct AMessage;

                    +class String8;

                    +class ASFExtractorImpl;

                    +

                    +typedef struct ASF_WRAPER

                    +{

                    +    ASFExtractorImpl* (*ASFExtractor)(

                    +        const sp<DataSource> &source);

                    +

                    +    void (*destructorASFExtractor)(ASFExtractorImpl *mHandle);

                    +

                    +    size_t (*countTracks)(ASFExtractorImpl *mHandle);

                    +

                    +    sp<MediaSource> (*getTrack)(

                    +        size_t index, ASFExtractorImpl *mHandle);

                    +

                    +    sp<MetaData> (*getTrackMetaData)(

                    +        size_t index,

                    +        uint32_t flags,

                    +        ASFExtractorImpl *mHandle);

                    +

                    +    sp<MetaData> (*getMetaData)(ASFExtractorImpl *mHandle);

                    +

                    +}ASF_WRAPER;

                    +

                    +class ASFExtractor : public MediaExtractor {

                    +public:

                    +    // Extractor assumes ownership of "source".

                    +    ASFExtractor(const sp<DataSource> &source);

                    +

                    +    virtual size_t countTracks();

                    +    virtual sp<MediaSource> getTrack(size_t index);

                    +    virtual sp<MetaData> getTrackMetaData(size_t index, uint32_t flags);

                    +

                    +    virtual sp<MetaData> getMetaData();

                    +

                    +protected:

                    +    virtual ~ASFExtractor();

                    +

                    +private:

                    +    ASF_WRAPER *pASFParser;

                    +    ASFExtractorImpl *mHandle;

                    +};

                    +

                    +bool SniffASF(const sp<DataSource> &source,

                    +              String8 *mimeType,

                    +              float *confidence,

                    +              sp<AMessage> *meta);

                    +

                    +bool isASFParserAvailable();

                    +void closeASFLib();

                    +

                    +}  // namespace android

                    +

                    +#endif  // ITTIAM_ASF_EXTRACTOR_H_

                    +

media/libstagefright/include/AwesomePlayer.h

show inline notes
View file @ 1a6862f

            
                    @@ -17,6 +17,12 @@

                     #ifndef AWESOME_PLAYER_H_

                     #define AWESOME_PLAYER_H_

                    +#ifdef OMAP_ENHANCEMENT

                    +#include <utils/Vector.h>

                    +#if defined(TARGET_OMAP4)

                    +#include "TISEIMessagesParser.h"

                    +#endif

                    +#endif

                     #include "NuHTTPDataSource.h"

                     #include "TimedEventQueue.h"

                    @@ -46,6 +52,13 @@ struct AwesomeRenderer : public RefBase {

                         virtual status_t initCheck() const = 0;

                         virtual void render(MediaBuffer *buffer) = 0;

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual Vector< sp<IMemory> > getBuffers() = 0;

                    +    virtual bool setCallback(release_rendered_buffer_callback cb, void *cookie) {return false;}

                    +    virtual void set_s3d_frame_layout(uint32_t s3d_mode, uint32_t s3d_fmt, uint32_t s3d_order, uint32_t s3d_subsampling){};

                    +    virtual void resizeRenderer(void* resize_params) = 0;

                    +    virtual void requestRendererClone(bool enable) = 0;

                    +#endif

                     private:

                         AwesomeRenderer(const AwesomeRenderer &);

                    @@ -89,13 +102,18 @@ struct AwesomePlayer {

                         status_t suspend();

                         status_t resume();

                    +#ifdef OMAP_ENHANCEMENT

                    +    status_t requestVideoCloneMode(bool enable);

                    +#endif

                         // This is a mask of MediaExtractor::Flags.

                         uint32_t flags() const;

                         void postAudioEOS();

                         void postAudioSeekComplete();

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +    void releaseRenderedBuffer(const sp<IMemory>& mem);

                    +#endif

                     private:

                         friend struct AwesomeEvent;

                    @@ -113,6 +131,22 @@ private:

                             AUTO_LOOPING        = 1024,

                         };

                    +#ifdef OMAP_ENHANCEMENT

                    +    enum {

                    +        HOLD_TO_RESUME      = 2048,

                    +        MAX_RESOLUTION      = 414720, // 864x480(WVGA) - 720x576(D1-PAL)

                    +    };

                    +    enum {

                    +         VID_MODE_NORMAL = 0,

                    +         VID_MODE_CLONE = 1

                    +      };

                    +

                    +    int mVideoMode;

                    +#if defined(TARGET_OMAP4)

                    +    S3D_params mS3Dparams;

                    +#endif

                    +#endif

                    +

                         mutable Mutex mLock;

                         Mutex mMiscStateLock;

                    @@ -179,7 +213,15 @@ private:

                         void postCheckAudioStatusEvent_l();

                         status_t play_l();

                    +#ifdef OMAP_ENHANCEMENT

                    +    Vector<MediaBuffer*> mBuffersWithRenderer;

                    +    bool mBufferReleaseCallbackSet;

                    +    bool mIsFirstVideoBuffer;

                    +    status_t mFirstVideoBufferResult;

                    +    MediaBuffer *mFirstVideoBuffer;

                    +#else

                         MediaBuffer *mLastVideoBuffer;

                    +#endif

                         MediaBuffer *mVideoBuffer;

                         sp<NuHTTPDataSource> mConnectingDataSource;

                    @@ -216,6 +258,12 @@ private:

                             }

                         } *mSuspensionState;

                    +#if defined(TARGET_OMAP4) && defined(OMAP_ENHANCEMENT)

                    +    bool configSEI2004Infos(OMX_OTHER_EXTRADATATYPE *extraData);

                    +    bool configSEI2010Infos(OMX_OTHER_EXTRADATATYPE *extraData);

                    +    void updateS3DRenderer();

                    +#endif

                    +

                         status_t setDataSource_l(

                                 const char *uri,

                                 const KeyedVector<String8, String8> *headers = NULL);

                    @@ -263,6 +311,10 @@ private:

                         AwesomePlayer(const AwesomePlayer &);

                         AwesomePlayer &operator=(const AwesomePlayer &);

                    +#ifdef OMAP_ENHANCEMENT

                    +    const char* mExtractorType;

                    +    sp<MediaExtractor> mExtractor;

                    +#endif

                     };

                     }  // namespace android

media/libstagefright/include/NuCachedSource2.h

show inline notes
View file @ 1a6862f

            
                    @@ -53,8 +53,13 @@ private:

                         enum {

                             kPageSize            = 65536,

                    +#ifndef OMAP_ENHANCEMENT

                             kHighWaterThreshold  = 5 * 1024 * 1024,

                             kLowWaterThreshold   = 512 * 1024,

                    +#else

                    +        kHighWaterThreshold  = 13 * 1024 * 1024,

                    +        kLowWaterThreshold   = 14 * 512 * 1024,

                    +#endif

                             // Read data after a 15 sec timeout whether we're actively

                             // fetching or not.

media/libstagefright/include/OMX.h

show inline notes
View file @ 1a6862f

            
                    @@ -88,6 +88,12 @@ public:

                                 node_id node, OMX_INDEXTYPE index,

                                 const void *params, size_t size);

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    virtual status_t useBuffer(

                    +            node_id node, OMX_U32 port_index, const sp<IMemory> &params,

                    +            buffer_id *buffer, size_t size);

                    +#endif

                    +

                         virtual status_t useBuffer(

                                 node_id node, OMX_U32 port_index, const sp<IMemory> &params,

                                 buffer_id *buffer);

                    @@ -123,6 +129,16 @@ public:

                                 size_t encodedWidth, size_t encodedHeight,

                                 size_t displayWidth, size_t displayHeight,

                                 int32_t rotationDegrees);

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual sp<IOMXRenderer> createRenderer(

                    +            const sp<ISurface> &surface,

                    +            const char *componentName,

                    +            OMX_COLOR_FORMATTYPE colorFormat,

                    +            size_t encodedWidth, size_t encodedHeight,

                    +            size_t displayWidth, size_t displayHeight,

                    +            int32_t rotationDegrees,

                    +            int isS3D, int numOfOpBuffers);

                    +#endif

                         virtual void binderDied(const wp<IBinder> &the_late_who);

media/libstagefright/include/OMXNodeInstance.h

show inline notes
View file @ 1a6862f

            
                    @@ -49,6 +49,12 @@ struct OMXNodeInstance {

                         status_t getConfig(OMX_INDEXTYPE index, void *params, size_t size);

                         status_t setConfig(OMX_INDEXTYPE index, const void *params, size_t size);

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    status_t useBuffer(

                    +            OMX_U32 portIndex, const sp<IMemory> &params,

                    +            OMX::buffer_id *buffer, size_t size);

                    +#endif

                    +

                         status_t useBuffer(

                                 OMX_U32 portIndex, const sp<IMemory> &params,

                                 OMX::buffer_id *buffer);

media/libstagefright/include/SampleTable.h

show inline notes
View file @ 1a6862f

            
                    @@ -46,6 +46,10 @@ public:

                         status_t setTimeToSampleParams(off_t data_offset, size_t data_size);

                    +#ifdef OMAP_ENHANCEMENT

                    +    status_t setTimeToSampleParamsCtts(off_t data_offset, size_t data_size);

                    +#endif

                    +

                         status_t setSyncSampleParams(off_t data_offset, size_t data_size);

                         ////////////////////////////////////////////////////////////////////////////

                    @@ -76,7 +80,9 @@ public:

                                 uint32_t flags);

                         status_t findThumbnailSample(uint32_t *sample_index);

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +  int32_t *mTimeToSampleCtts;

                    +#endif

                     protected:

                         ~SampleTable();

                    @@ -124,6 +130,12 @@ private:

                         SampleTable(const SampleTable &);

                         SampleTable &operator=(const SampleTable &);

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +    uint32_t mTimeToSampleCountCtts;

                    +    int32_t *mCttsSampleBuffer;

                    +#endif

                    +

                     };

                     }  // namespace android

media/libstagefright/include/SoftwareRenderer.h

show inline notes
View file @ 1a6862f

            
                    @@ -42,6 +42,11 @@ public:

                         virtual void render(

                                 const void *data, size_t size, void *platformPrivate);

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual Vector< sp<IMemory> > getBuffers();

                    +    virtual void resizeRenderer(void* resize_params) {}

                    +    virtual void requestRendererClone(bool enable) {}

                    +#endif

                     private:

                         status_t mInitCheck;

media/libstagefright/include/TISEIMessagesParser.h

show inline notes
View file @ 1a6862f

            
                    @@ -0,0 +1,88 @@

                    +/*

                    + * Copyright (C) Texas Instruments - http://www.ti.com/

                    + *

                    + * This library is free software; you can redistribute it and/or

                    + * modify it under the terms of the GNU Lesser General Public

                    + * License as published by the Free Software Foundation; either

                    + * version 2.1 of the License, or (at your option) any later version.

                    + *

                    + *

                    + * This library is distributed in the hope that it will be useful,

                    + * but WITHOUT ANY WARRANTY; without even the implied warranty of

                    + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

                    + * Lesser General Public License for more details.

                    + *

                    + *

                    + * You should have received a copy of the GNU Lesser General Public

                    + * License along with this library; if not, write to the Free Software

                    + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

                    + */

                    +

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +

                    +#ifndef TI_SEI_MESSAGES_PARSER_H_INCLUDED

                    +#define TI_SEI_MESSAGES_PARSER_H_INCLUDED

                    +

                    +#include <utils/Log.h>

                    +

                    +namespace android {

                    +

                    +/*values for possible S3D modes*/

                    +enum {

                    +    S3D_MODE_OFF = 0,

                    +    S3D_MODE_ON = 1,

                    +    S3D_MODE_ANAGLYPH = 2,

                    +};

                    +

                    +/*values for possible S3D format types*/

                    +enum {

                    +    S3D_FORMAT_NONE = 0,

                    +    S3D_FORMAT_OVERUNDER,

                    +    S3D_FORMAT_SIDEBYSIDE,

                    +    S3D_FORMAT_ROW_IL,

                    +    S3D_FORMAT_COL_IL,

                    +    S3D_FORMAT_PIX_IL,

                    +    S3D_FORMAT_CHECKB,

                    +    S3D_FORMAT_FRM_SEQ,

                    +};

                    +

                    +/*values for possible S3D order types*/

                    +enum {

                    +    S3D_ORDER_LF = 0,

                    +    S3D_ORDER_RF,

                    +};

                    +

                    +/*values for possible S3D subsampling modes*/

                    +enum {

                    +    S3D_SS_NONE = 0,

                    +    S3D_SS_HOR,

                    +    S3D_SS_VERT,

                    +};

                    +

                    +/*values for possible S3D SEI messages types*/

                    +enum {

                    +    S3D_SEI_NONE = 0,                                   /* Regular Interlaced or Progressive stream */

                    +    S3D_SEI_STEREO_INFO_PROGRESSIVE,    /* 2004 Progressive */

                    +    S3D_SEI_STEREO_INFO_INTERLACED,     /*  2004 Interlaced */

                    +    S3D_SEI_STEREO_FRAME_PACKING,       /*  2010 Progressive */

                    +};

                    +

                    +struct S3D_params

                    +{

                    +    bool active;

                    +    uint32_t mode;

                    +    uint32_t fmt;

                    +    uint32_t order;

                    +    uint32_t subsampling;

                    +    uint32_t metadata;

                    +};

                    +

                    +#define AVC_NALTYPE_SEI 6  /* Supplemental Enhancement Info */

                    +void set_frame_packing_arrangement_type(uint32_t frame_packing_arrangement_type, uint32_t &format, uint32_t &subsampling);

                    +int32_t AVCGetNALType(uint8_t *bitstream, int size, int *nal_type, int *nal_ref_idc);

                    +int16_t sei_rbsp(uint8_t *buffer, int32_t length, S3D_params &mS3Dparams);

                    +

                    +}

                    +#endif //TI_M4V_CONFIG_PARSER_H_INCLUDED

                    +#endif //OMAP_ENHANCEMENT

                    +

media/libstagefright/omx/OMX.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -306,6 +306,15 @@ status_t OMX::setConfig(

                                 index, params, size);

                     }

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +status_t OMX::useBuffer(

                    +        node_id node, OMX_U32 port_index, const sp<IMemory> &params,

                    +        buffer_id *buffer, size_t size) {

                    +    return findInstance(node)->useBuffer(

                    +            port_index, params, buffer, size);

                    +}

                    +#endif

                    +

                     status_t OMX::useBuffer(

                             node_id node, OMX_U32 port_index, const sp<IMemory> &params,

                             buffer_id *buffer) {

                    @@ -484,6 +493,27 @@ struct SharedVideoRenderer : public VideoRenderer {

                             return mObj->render(data, size, platformPrivate);

                         }

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual Vector< sp<IMemory> > getBuffers() {

                    +        return mObj->getBuffers();

                    +    }

                    +

                    +    virtual bool setCallback(release_rendered_buffer_callback cb, void *cookie) {

                    +        return mObj->setCallback(cb, cookie);

                    +    }

                    +

                    +    virtual void set_s3d_frame_layout(uint32_t s3d_mode, uint32_t s3d_fmt, uint32_t s3d_order, uint32_t s3d_subsampling) {

                    +    mObj->set_s3d_frame_layout(s3d_mode, s3d_fmt, s3d_order, s3d_subsampling);

                    +     }

                    +

                    +    virtual void resizeRenderer(void* resize_params) {

                    +          mObj->resizeRenderer(resize_params);

                    +    }

                    +virtual void requestRendererClone(bool enable) {

                    +    mObj->requestRendererClone(enable);

                    +}

                    +#endif

                    +

                     private:

                         void *mLibHandle;

                         VideoRenderer *mObj;

                    @@ -575,6 +605,86 @@ sp<IOMXRenderer> OMX::createRenderer(

                         return new OMXRenderer(impl);

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +sp<IOMXRenderer> OMX::createRenderer(

                    +        const sp<ISurface> &surface,

                    +        const char *componentName,

                    +        OMX_COLOR_FORMATTYPE colorFormat,

                    +        size_t encodedWidth, size_t encodedHeight,

                    +        size_t displayWidth, size_t displayHeight,

                    +        int32_t rotationDegrees,

                    +        int isS3D, int numOfOpBuffers) {

                    +    Mutex::Autolock autoLock(mLock);

                    +    VideoRenderer *impl = NULL;

                    +    void *libHandle = dlopen("libstagefrighthw.so", RTLD_NOW);

                    +

                    +    if (libHandle) {

                    +        typedef VideoRenderer *(*CreateRendererWithRotationFunc)(

                    +                const sp<ISurface> &surface,

                    +                const char *componentName,

                    +                OMX_COLOR_FORMATTYPE colorFormat,

                    +                size_t displayWidth, size_t displayHeight,

                    +                size_t decodedWidth, size_t decodedHeight,

                    +                int32_t rotationDegrees,

                    +                int isS3D, int numOfOpBuffers);

                    +

                    +        typedef VideoRenderer *(*CreateRendererFunc)(

                    +                const sp<ISurface> &surface,

                    +                const char *componentName,

                    +                OMX_COLOR_FORMATTYPE colorFormat,

                    +                size_t displayWidth, size_t displayHeight,

                    +                size_t decodedWidth, size_t decodedHeight,

                    +                int isS3D, int numOfOpBuffers);

                    +

                    +        CreateRendererWithRotationFunc funcWithRotation =

                    +            (CreateRendererWithRotationFunc)dlsym(

                    +                    libHandle,

                    +                    "_Z26createRendererWithRotationRKN7android2spINS_8"

                    +                    "ISurfaceEEEPKc20OMX_COLOR_FORMATTYPEjjjjiii");

                    +

                    +        if (funcWithRotation) {

                    +            impl = (*funcWithRotation)(

                    +                    surface, componentName, colorFormat,

                    +                    displayWidth, displayHeight, encodedWidth, encodedHeight,

                    +                    rotationDegrees,

                    +                    isS3D, numOfOpBuffers);

                    +        } else {

                    +            CreateRendererFunc func =

                    +                (CreateRendererFunc)dlsym(

                    +                        libHandle,

                    +                        "_Z14createRendererRKN7android2spINS_8ISurfaceEEEPKc20"

                    +                        "OMX_COLOR_FORMATTYPEjjjjii");

                    +            if (func) {

                    +                impl = (*func)(surface, componentName, colorFormat,

                    +                        displayWidth, displayHeight, encodedWidth, encodedHeight,

                    +                        isS3D, numOfOpBuffers);

                    +            }

                    +        }

                    +

                    +        if (impl) {

                    +            impl = new SharedVideoRenderer(libHandle, impl);

                    +            libHandle = NULL;

                    +        }

                    +

                    +        if (libHandle) {

                    +            dlclose(libHandle);

                    +            libHandle = NULL;

                    +        }

                    +    }

                    +

                    +    if (!impl) {

                    +        LOGE("Using software renderer.");

                    +        impl = new SoftwareRenderer(

                    +                colorFormat,

                    +                surface,

                    +                displayWidth, displayHeight,

                    +                encodedWidth, encodedHeight);

                    +    }

                    +

                    +    return new OMXRenderer(impl);

                    +}

                    +#endif

                    +

                     OMXRenderer::OMXRenderer(VideoRenderer *impl)

                         : mImpl(impl) {

                     }

                    @@ -593,5 +703,28 @@ void OMXRenderer::render(IOMX::buffer_id buffer) {

                                 header->pPlatformPrivate);

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +Vector< sp<IMemory> > OMXRenderer::getBuffers() {

                    +    return mImpl->getBuffers();

                    +}

                    +

                    +bool OMXRenderer::setCallback(release_rendered_buffer_callback cb, void *cookie) {

                    +    return mImpl->setCallback(cb, cookie);

                    +}

                    +

                    +void OMXRenderer::set_s3d_frame_layout(uint32_t s3d_mode, uint32_t s3d_fmt, uint32_t s3d_order, uint32_t s3d_subsampling) {

                    +    mImpl->set_s3d_frame_layout(s3d_mode, s3d_fmt, s3d_order, s3d_subsampling);

                    +}

                    +

                    +void OMXRenderer::resizeRenderer(void* resize_params) {

                    +    mImpl->resizeRenderer(resize_params);

                    +}

                    +

                    +void OMXRenderer::requestRendererClone(bool enable) {

                    +    mImpl->requestRendererClone(enable);

                    +}

                    +

                    +#endif

                    +

                     }  // namespace android

media/libstagefright/omx/OMXNodeInstance.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -253,16 +253,42 @@ status_t OMXNodeInstance::setConfig(

                         return StatusFromOMXError(err);

                     }

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                     status_t OMXNodeInstance::useBuffer(

                    -        OMX_U32 portIndex, const sp<IMemory> &params,

                    -        OMX::buffer_id *buffer) {

                    +                OMX_U32 portIndex, const sp<IMemory> &params,

                    +                OMX::buffer_id *buffer) {

                    +        return useBuffer(portIndex, params, buffer, 0);

                    +}

                    +#endif

                    +

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +status_t OMXNodeInstance::useBuffer(

                    +                OMX_U32 portIndex, const sp<IMemory> &params,

                    +                OMX::buffer_id *buffer, size_t size) {

                    +#else

                    +status_t OMXNodeInstance::useBuffer(

                    +                OMX_U32 portIndex, const sp<IMemory> &params,

                    +                OMX::buffer_id *buffer) {

                    +#endif

                         Mutex::Autolock autoLock(mLock);

                         BufferMeta *buffer_meta = new BufferMeta(params);

                         OMX_BUFFERHEADERTYPE *header;

                    -#ifdef USE_GETBUFFERINFO

                    +#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)

                    +    OMX_ERRORTYPE err;

                    +

                    +    if(params.get() != NULL) {

                    +        err = OMX_UseBuffer(

                    +                mHandle, &header, portIndex, buffer_meta,

                    +                params->size(), static_cast<OMX_U8 *>(params->pointer()));

                    +    } else {

                    +        err = OMX_UseBuffer(

                    +                mHandle, &header, portIndex, buffer_meta,

                    +                size, NULL);

                    +    }

                    +#elif defined(USE_GETBUFFERINFO)

                         OMX_QCOM_PLATFORM_PRIVATE_PMEM_INFO pmem_info;

                         ssize_t offset;

                         size_t size;

media/libstagefright/omx/OMXRenderer.h

show inline notes
View file @ 1a6862f

            
                    @@ -31,6 +31,14 @@ public:

                         virtual ~OMXRenderer();

                         virtual void render(IOMX::buffer_id buffer);

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual Vector< sp<IMemory> > getBuffers();

                    +    virtual bool setCallback(release_rendered_buffer_callback cb, void *cookie);

                    +

                    +    virtual void set_s3d_frame_layout(uint32_t s3d_mode, uint32_t s3d_fmt, uint32_t s3d_order, uint32_t s3d_subsampling);

                    +    virtual void resizeRenderer(void* resize_params);

                    +    virtual void requestRendererClone(bool enable);

                    +#endif

                     private:

                         VideoRenderer *mImpl;

omapmmlib/Android.mk

show inline notes
View file @ 1a6862f

            
                    @@ -0,0 +1,44 @@

                    +#

                    +# Copyright (C) 2008 The Android Open Source Project

                    +#

                    +# Licensed under the Apache License, Version 2.0 (the "License");

                    +# you may not use this file except in compliance with the License.

                    +# You may obtain a copy of the License at

                    +#

                    +#      http://www.apache.org/licenses/LICENSE-2.0

                    +#

                    +# Unless required by applicable law or agreed to in writing, software

                    +# distributed under the License is distributed on an "AS IS" BASIS,

                    +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

                    +# See the License for the specific language governing permissions and

                    +# limitations under the License.

                    +#

                    +

                    +# This makefile shows how to build your own shared library that can be

                    +# shipped on the system of a phone, and included additional examples of

                    +# including JNI code with the library and writing controller applications against it.

                    +

                    +LOCAL_PATH := $(call my-dir)

                    +

                    +# the library

                    +# ============================================================

                    +include $(CLEAR_VARS)

                    +

                    +LOCAL_SRC_FILES := \

                    +            $(call all-subdir-java-files)

                    +

                    +LOCAL_MODULE_TAGS := optional

                    +

                    +# This is the target being built.

                    +LOCAL_MODULE:= com.ti.omap.omap_mm_library

                    +

                    +include $(BUILD_JAVA_LIBRARY)

                    +

                    +# The JNI component

                    +# ============================================================

                    +# Also build all of the sub-targets under this one: the library's

                    +# associated JNI code, and a sample controller of the library.

                    +include $(CLEAR_VARS)

                    +

                    +include $(call all-makefiles-under,$(LOCAL_PATH))

                    +

omapmmlib/com.ti.omap.omap_mm_library.xml

show inline notes
View file @ 1a6862f

            
                    @@ -0,0 +1,5 @@

                    +<?xml version="1.0" encoding="utf-8"?>

                    +<permissions>

                    +    <library name="com.ti.omap.omap_mm_library"

                    +            file="/system/framework/com.ti.omap.omap_mm_library.jar"/>

                    +</permissions>

omapmmlib/java/com/ti/omap/omap_mm_library/OmapMMLibrary.java

show inline notes
View file @ 1a6862f

            
                    @@ -0,0 +1,65 @@

                    +/*

                    + * Copyright (C) 2008 The Android Open Source Project

                    + *

                    + * Licensed under the Apache License, Version 2.0 (the "License");

                    + * you may not use this file except in compliance with the License.

                    + * You may obtain a copy of the License at

                    + *

                    + *      http://www.apache.org/licenses/LICENSE-2.0

                    + *

                    + * Unless required by applicable law or agreed to in writing, software

                    + * distributed under the License is distributed on an "AS IS" BASIS,

                    + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

                    + * See the License for the specific language governing permissions and

                    + * limitations under the License.

                    + */

                    +

                    +package com.ti.omap.omap_mm_library;

                    +

                    +import android.util.Config;

                    +import android.util.Log;

                    +import android.view.Surface;

                    +import android.view.SurfaceHolder;

                    +import android.media.MediaPlayer;

                    +

                    +public final class OmapMMLibrary {

                    +private String TAG = "OmapMMJavaLib";

                    +static {

                    +        /*

                    +        * Load the library.  If it's already loaded, this does nothing.

                    +        */

                    +        System.loadLibrary("omap_mm_library_jni");

                    +    }

                    +

                    +    private Surface mSurface; // accessed by native methods

                    +    private MediaPlayer mMediaPlayer; // accessed by native methods

                    +

                    +    public OmapMMLibrary() {

                    +    }

                    +

                    +    public void setVideoSurface(SurfaceHolder sh) {

                    +        if (sh != null) {

                    +            mSurface = sh.getSurface();

                    +        } else {

                    +            mSurface = null;

                    +      return;

                    +        }

                    +        //This is native implemented, to get the associated ISurface

                    +        setVideoISurface();

                    +    }

                    +

                    +    public void setMediaPlayer(MediaPlayer mp) {

                    +            mMediaPlayer = mp;

                    +      return;

                    +        }

                    +

                    +    /*

                    +    * init will mount required fields

                    +    */

                    +    native public void native_init();

                    +    native private void deinit();

                    +    native public void setVideoISurface();

                    +    native public void setDisplayId(int displayId);

                    +

                    +}

                    +

omapmmlib/java/com/ti/omap/omap_mm_library/UiCloningService.java

show inline notes
View file @ 1a6862f

            
                    @@ -0,0 +1,71 @@

                    +/*

                    + * Copyright (C) 2008 The Android Open Source Project

                    + *

                    + * Licensed under the Apache License, Version 2.0 (the "License");

                    + * you may not use this file except in compliance with the License.

                    + * You may obtain a copy of the License at

                    + *

                    + *      http://www.apache.org/licenses/LICENSE-2.0

                    + *

                    + * Unless required by applicable law or agreed to in writing, software

                    + * distributed under the License is distributed on an "AS IS" BASIS,

                    + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

                    + * See the License for the specific language governing permissions and

                    + * limitations under the License.

                    + */

                    +

                    +package com.ti.omap.omap_mm_library;

                    +

                    +import android.content.Context;

                    +import android.content.BroadcastReceiver;

                    +import android.content.Intent;

                    +import android.content.IntentFilter;

                    +

                    +import android.util.Log;

                    +

                    +public final class UiCloningService {

                    +    private String TAG = "UiCloningService";

                    +

                    +    static {

                    +        /*

                    +         * Load the library.  If it's already loaded, this does nothing.

                    +         */

                    +        System.loadLibrary("omap_mm_library_jni");

                    +    }

                    +

                    +    // All possible Display Types on OMAP4.

                    +    private static final int DISPLAY_TYPE_NONE          = -1;

                    +    private static final int DISPLAY_TYPE_LCD_SECONDARY = 1;

                    +    private static final int DISPLAY_TYPE_HDMI_TV       = 2;

                    +

                    +    private static final String ACTION_HDMI_PLUG = "android.intent.action.HDMI_PLUG";

                    +    // Broadcast receiver for device connections intent broadcasts

                    +    private final BroadcastReceiver mReceiver = new UiCloningBroadcastReceiver();

                    +

                    +    public UiCloningService(Context context) {

                    +        IntentFilter intentFilter = new IntentFilter(ACTION_HDMI_PLUG);

                    +        context.registerReceiver(mReceiver, intentFilter);

                    +    }

                    +

                    +    private class UiCloningBroadcastReceiver extends BroadcastReceiver {

                    +        @Override

                    +        public void onReceive(Context context, Intent intent) {

                    +            String action = intent.getAction();

                    +

                    +            if (action.equals(ACTION_HDMI_PLUG)) {

                    +                int state = intent.getIntExtra("state", 0);

                    +

                    +                if(state==1) {

                    +                    Log.d(TAG, "UiCloningBroadcastReceiver.onReceive() : Cloning UI to HDMI-TV");

                    +                    CloneUiToDisplay(DISPLAY_TYPE_HDMI_TV);

                    +                } else {

                    +                    Log.d(TAG, "UiCloningBroadcastReceiver.onReceive() : Stopping UI on HDMI-TV");

                    +                    CloneUiToDisplay(DISPLAY_TYPE_NONE);

                    +                }

                    +            }

                    +        }

                    +    }

                    +

                    +    native public void CloneUiToDisplay(int displayId);

                    +}

                    +

omapmmlib/jni/Android.mk

show inline notes
View file @ 1a6862f

            
                    @@ -0,0 +1,61 @@

                    +#

                    +# Copyright (C) 2008 The Android Open Source Project

                    +#

                    +# Licensed under the Apache License, Version 2.0 (the "License");

                    +# you may not use this file except in compliance with the License.

                    +# You may obtain a copy of the License at

                    +#

                    +#      http://www.apache.org/licenses/LICENSE-2.0

                    +#

                    +# Unless required by applicable law or agreed to in writing, software

                    +# distributed under the License is distributed on an "AS IS" BASIS,

                    +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

                    +# See the License for the specific language governing permissions and

                    +# limitations under the License.

                    +#

                    +

                    +# This makefile supplies the rules for building a library of JNI code for

                    +# use by our example platform shared library.

                    +

                    +ifeq ($(OMAP_ENHANCEMENT),true)

                    +LOCAL_PATH:= $(call my-dir)

                    +include $(CLEAR_VARS)

                    +

                    +LOCAL_MODULE_TAGS := optional

                    +

                    +# This is the target being built.

                    +LOCAL_MODULE:= libomap_mm_library_jni

                    +

                    +# All of the source files that we will compile.

                    +LOCAL_SRC_FILES:= \

                    +            OmapMMLibrary.cpp \

                    +            UiCloningService.cpp

                    +

                    +# All of the shared libraries we link against.

                    +LOCAL_SHARED_LIBRARIES := \

                    +        libandroid_runtime \

                    +        libnativehelper \

                    +        libcutils \

                    +        libutils\

                    +        libbinder \

                    +        libui \

                    +        libsurfaceflinger_client \

                    +        libmedia

                    +

                    +# No static libraries.

                    +LOCAL_STATIC_LIBRARIES :=

                    +

                    +# Also need the JNI headers.

                    +LOCAL_C_INCLUDES := \

                    +        frameworks/base/core/libs \

                    +        $(JNI_H_INCLUDE)

                    +

                    +# No special compiler flags.

                    +LOCAL_CFLAGS +=

                    +

                    +# Don't prelink this library.  For more efficient code, you may want

                    +# to add this library to the prelink map and set this to true.

                    +LOCAL_PRELINK_MODULE := false

                    +

                    +include $(BUILD_SHARED_LIBRARY)

                    +endif

omapmmlib/jni/OmapMMLibrary.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -0,0 +1,309 @@

                    +/*

                    + * Copyright (C) 2008 The Android Open Source Project

                    + *

                    + * Licensed under the Apache License, Version 2.0 (the "License");

                    + * you may not use this file except in compliance with the License.

                    + * You may obtain a copy of the License at

                    + *

                    + *      http://www.apache.org/licenses/LICENSE-2.0

                    + *

                    + * Unless required by applicable law or agreed to in writing, software

                    + * distributed under the License is distributed on an "AS IS" BASIS,

                    + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

                    + * See the License for the specific language governing permissions and

                    + * limitations under the License.

                    + */

                    +

                    +#define LOG_TAG "OmapMMLibrary"

                    +#include "utils/Log.h"

                    +

                    +#include <stdlib.h>

                    +#include <string.h>

                    +#include <unistd.h>

                    +#include <assert.h>

                    +#include <stdio.h>

                    +

                    +#include "jni.h"

                    +#include <surfaceflinger/Surface.h>

                    +#include <surfaceflinger/ISurface.h>

                    +#include <binder/Parcel.h>

                    +#include <utils/RefBase.h>

                    +#include <media/mediaplayer.h>

                    +

                    +using namespace android;

                    +

                    +// ----------------------------------------------------------------------------

                    +namespace android {

                    +//friend class for Surface, so that it can extract ISurface

                    +class OmapMMLibrary {

                    +    public:

                    +        void getISurface(const sp<Surface>& s) {

                    +            mSurface =  s->getISurface();

                    +            return;

                    +        }

                    +    sp<ISurface> mSurface;

                    +    };

                    +}

                    +

                    +static OmapMMLibrary omapmmlib;

                    +/*

                    + * Field/method IDs and class object references.

                    + *

                    + * You should not need to store the JNIEnv pointer in here.  It is

                    + * thread-specific and will be passed back in on every call.

                    + */

                    +struct fields_t{

                    +    jclass      omapMMLibraryClass;

                    +    jfieldID    jniInt;

                    +    jfieldID    mysurface;

                    +    /* actually in android.view.Surface XXX */

                    +    jfieldID    mysurface_native;

                    +    jfieldID    mediaplayer;

                    +    jfieldID    mediaplayer_native;

                    +};

                    +

                    +static fields_t fields;

                    +

                    +// ----------------------------------------------------------------------------

                    +

                    +/*

                    + * Helper function to throw an arbitrary exception.

                    + *

                    + * Takes the exception class name, a format string, and one optional integer

                    + * argument (useful for including an error code, perhaps from errno).

                    + */

                    +static void jniThrowException(JNIEnv* env, const char* ex, const char* fmt,

                    +    int data) {

                    +        if (jclass cls = env->FindClass(ex)) {

                    +            if (fmt != NULL) {

                    +                char msg[1000];

                    +                snprintf(msg, sizeof(msg), fmt, data);

                    +                env->ThrowNew(cls, msg);

                    +            } else {

                    +                env->ThrowNew(cls, NULL);

                    +            }

                    +        /*

                    +         * This is usually not necessary -- local references are released

                    +         * automatically when the native code returns to the VM.  It's

                    +         * required if the code doesn't actually return, e.g. it's sitting

                    +         * in a native event loop.

                    +         */

                    +        env->DeleteLocalRef(cls);

                    +    }

                    +}

                    +/**

                    +  Initialization steps:

                    +  1. init fields

                    +**/

                    +static void OmapMMLibrary_native_init(JNIEnv* env, jclass clazz1) {

                    +    static const char* const kClassName =

                    +        "com/ti/omap/omap_mm_library/OmapMMLibrary";

                    +    jclass clazz;

                    +

                    +    /* look up the class */

                    +    clazz = env->FindClass(kClassName);

                    +    if (clazz == NULL) {

                    +        LOGE("Can't find class %s\n", kClassName);

                    +        return;

                    +    }

                    +

                    +       fields.mysurface = env->GetFieldID(clazz, "mSurface", "Landroid/view/Surface;");

                    +    if (fields.mysurface == NULL) {

                    +        jniThrowException(env, "java/lang/RuntimeException", "Can't find MMLibrary.mSurface", 0);

                    +        return;

                    +    }

                    +

                    +    jclass mysurface = env->FindClass("android/view/Surface");

                    +    if (mysurface == NULL) {

                    +        jniThrowException(env, "java/lang/RuntimeException", "Can't find android/view/Surface", 0);

                    +        return;

                    +    }

                    +

                    +    fields.mysurface_native = env->GetFieldID(mysurface, "mNativeSurface", "I");

                    +    if (fields.mysurface_native == NULL) {

                    +        jniThrowException(env, "java/lang/RuntimeException", "Can't find Surface.mSurface", 0);

                    +        return;

                    +    }

                    +

                    +    fields.mediaplayer = env->GetFieldID(clazz, "mMediaPlayer", "Landroid/media/MediaPlayer;");

                    +    if (fields.mediaplayer == NULL) {

                    +        jniThrowException(env, "java/lang/RuntimeException", "Can't find android/media/MediaPlayer", 0);

                    +        return;

                    +    }

                    +

                    +    jclass mp = env->FindClass("android/media/MediaPlayer");

                    +    if (mp == NULL) {

                    +        jniThrowException(env, "java/lang/RuntimeException", "Can't find android/media/MediaPlayer", 0);

                    +        return;

                    +    }

                    +

                    +    fields.mediaplayer_native = env->GetFieldID(mp, "mNativeContext", "I");

                    +    if (fields.mediaplayer_native == NULL) {

                    +        jniThrowException(env, "java/lang/RuntimeException", "Can't find MediaPlayer.mNativeContext", 0);

                    +        return;

                    +    }

                    +

                    +

                    +    return;

                    +}

                    +

                    +/**

                    +  Deinitialization steps:

                    +  1. do nothing for now

                    +**/

                    +static void OmapMMLibrary_deinit(JNIEnv* env, jclass clazz) {

                    +    return;

                    +}

                    +

                    +

                    +/**

                    +* a method to set the requested Display Id.

                    +*

                    +* Input: integer between 0 and 3

                    +* 0 - PRIMARY DISPLAY

                    +* 1 - SECONDARY DISPLAY

                    +* 2 - HDTV

                    +* 3 - pico DLP

                    +* these enums should be in sync with overlay enums

                    +**/

                    +static void OmapMMLibrary_setDisplayId(JNIEnv* env, jclass clazz, int displayId) {

                    +    LOGD("displayId[%d]", displayId);

                    +    jobject myplayer = env->GetObjectField(clazz, fields.mediaplayer);

                    +    if (myplayer != NULL) { //media player would be null for switch usecases

                    +        MediaPlayer* const p = (MediaPlayer*)env->GetIntField(myplayer, fields.mediaplayer_native);

                    +        if (p) {

                    +            if (displayId != 0) {

                    +                p->requestVideoCloneMode(1);

                    +            }

                    +            else {

                    +                p->requestVideoCloneMode(0);

                    +            }

                    +        }

                    +    }

                    +    if (omapmmlib.mSurface != NULL) {

                    +        omapmmlib.mSurface->setDisplayId(displayId);

                    +    }

                    +    return;

                    +}

                    +

                    +/**

                    +* a method to set the ISurface for requested Surface.

                    +* Surface was already set in JAVA class method.

                    +*

                    +**/

                    +static void OmapMMLibrary_setVideoISurface(JNIEnv* env, jclass clazz) {

                    +    jobject mysurface = env->GetObjectField(clazz, fields.mysurface);

                    +    if (mysurface != NULL) {

                    +        sp<Surface> native_surface = (Surface*)env->GetIntField(mysurface, fields.mysurface_native);

                    +        //LOGD("surface=%p (id=%d)",native_surface.get(), native_surface->ID());

                    +        if (native_surface.get() != NULL) {

                    +            omapmmlib.getISurface(native_surface);

                    +            //msurface is ready now

                    +        }

                    +    }

                    +    return;

                    +}

                    +

                    +// ----------------------------------------------------------------------------

                    +

                    +/*

                    + * Array of methods.

                    + *

                    + * Each entry has three fields: the name of the method, the method

                    + * signature, and a pointer to the native implementation.

                    + */

                    +static const JNINativeMethod gMethods[] = {

                    +    { "native_init","()V", (void*)OmapMMLibrary_native_init },

                    +    { "deinit","()V", (void*)OmapMMLibrary_deinit },

                    +    { "setVideoISurface","()V", (void*)OmapMMLibrary_setVideoISurface },

                    +    { "setDisplayId","(I)V", (void*)OmapMMLibrary_setDisplayId },

                    +};

                    +

                    +/*

                    + * Do some (slow-ish) lookups now and save the results.

                    + *

                    + * Returns 0 on success.

                    + */

                    +static int cacheIds(JNIEnv* env, jclass clazz) {

                    +    /*

                    +     * Save the class in case we want to use it later.  Because this is a

                    +     * reference to the Class object, we need to convert it to a JNI global

                    +     * reference.

                    +     */

                    +    fields.omapMMLibraryClass = (jclass) env->NewGlobalRef(clazz);

                    +    if (clazz == NULL) {

                    +        LOGE("Can't create new global ref\n");

                    +        return -1;

                    +    }

                    +

                    +    return 0;

                    +}

                    +

                    +/*

                    + * Explicitly register all methods for our class.

                    + *

                    + * While we're at it, cache some class references and method/field IDs.

                    + *

                    + * Returns 0 on success.

                    + */

                    +static int registerMethods(JNIEnv* env) {

                    +    static const char* const kClassName =

                    +        "com/ti/omap/omap_mm_library/OmapMMLibrary";

                    +    jclass clazz;

                    +

                    +    /* look up the class */

                    +    clazz = env->FindClass(kClassName);

                    +    if (clazz == NULL) {

                    +        LOGE("Can't find class %s\n", kClassName);

                    +        return -1;

                    +    }

                    +

                    +    /* register all the methods */

                    +    if (env->RegisterNatives(clazz, gMethods,

                    +            sizeof(gMethods) / sizeof(gMethods[0])) != JNI_OK)

                    +    {

                    +        LOGE("Failed registering methods for %s\n", kClassName);

                    +        return -1;

                    +    }

                    +

                    +    /* fill out the rest of the ID cache */

                    +    return cacheIds(env, clazz);

                    +}

                    +

                    +extern int UiCloningService_registerMethods(JNIEnv* env);

                    +

                    +// ----------------------------------------------------------------------------

                    +

                    +/*

                    + * This is called by the VM when the shared library is first loaded.

                    + */

                    +jint JNI_OnLoad(JavaVM* vm, void* reserved) {

                    +    JNIEnv* env = NULL;

                    +    jint result = -1;

                    +

                    +    if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {

                    +        LOGE("ERROR: GetEnv failed\n");

                    +        goto bail;

                    +    }

                    +    assert(env != NULL);

                    +

                    +    if (registerMethods(env) != 0) {

                    +        LOGE("ERROR: PlatformLibrary native registration failed\n");

                    +        goto bail;

                    +    }

                    +

                    +    if (UiCloningService_registerMethods(env) != 0) {

                    +        LOGE("ERROR: PlatformLibrary native registration for UiCloningService failed\n");

                    +        goto bail;

                    +    }

                    +

                    +    /* success -- return valid version number */

                    +    result = JNI_VERSION_1_4;

                    +

                    +bail:

                    +    return result;

                    +}

                    +

                    +

                    +

                    +

omapmmlib/jni/UiCloningService.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -0,0 +1,203 @@

                    +/*

                    + * Copyright (C) 2008 The Android Open Source Project

                    + *

                    + * Licensed under the Apache License, Version 2.0 (the "License");

                    + * you may not use this file except in compliance with the License.

                    + * You may obtain a copy of the License at

                    + *

                    + *      http://www.apache.org/licenses/LICENSE-2.0

                    + *

                    + * Unless required by applicable law or agreed to in writing, software

                    + * distributed under the License is distributed on an "AS IS" BASIS,

                    + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

                    + * See the License for the specific language governing permissions and

                    + * limitations under the License.

                    + */

                    +

                    +#define LOG_TAG "UiCloningService"

                    +#include "utils/Log.h"

                    +

                    +#include "jni.h"

                    +#include <binder/Parcel.h>

                    +

                    +#include <fcntl.h>

                    +

                    +using namespace android;

                    +

                    +/*

                    + * Notes for Currently supported UI-Cloning-Feature

                    + *

                    + * 1. fb0 is on Overlay0 which is on LCD1.

                    + * 2. fb1 is on Overlay1 which can go to LCD2 or TV.

                    + * 3. UI-Cloning is supported on LCD2 and TV.

                    + * 4. Cloning of only fb0 is supported.

                    + * 5. For cloning of fb0 on Overlay1, fb1 is switched off.

                    + */

                    +

                    +const char fb0Overlays [PATH_MAX] = "/sys/class/graphics/fb0/overlays";

                    +const char fb1Overlays [PATH_MAX] = "/sys/class/graphics/fb1/overlays";

                    +const char fb0FitToScreenOption[PATH_MAX] = "/sys/class/graphics/fb0/fit_to_screen";

                    +const char overlay1ManagerName[PATH_MAX] = "/sys/devices/platform/omapdss/overlay1/manager";

                    +const char overlay1ManagerEnabled[PATH_MAX] = "/sys/devices/platform/omapdss/overlay1/enabled";

                    +

                    +enum displayId {

                    +    DISPLAYID_NONE = -1,

                    +    DISPLAYID_LCDSECONDARY = 1,

                    +    DISPLAYID_TVHDMI = 2,

                    +};

                    +

                    +/*

                    + * Helper function to throw an arbitrary exception.

                    + *

                    + * Takes the exception class name, a format string

                    + */

                    +static void jniThrowException(JNIEnv* env, const char* ex, const char* msg = NULL)

                    +{

                    +    if (jclass cls = env->FindClass(ex)) {

                    +        env->ThrowNew(cls, msg);

                    +        /*

                    +         * This is usually not necessary -- local references are released

                    +         * automatically when the native code returns to the VM.  It's

                    +         * required if the code doesn't actually return, e.g. it's sitting

                    +         * in a native event loop.

                    +         */

                    +        env->DeleteLocalRef(cls);

                    +    }

                    +}

                    +

                    +int sysfile_write(const char* pathname, const void* buf, size_t size) {

                    +    int fd = open(pathname, O_WRONLY);

                    +    if (fd == -1) {

                    +        LOGE("Can't open [%s]", pathname);

                    +        return -1;

                    +    }

                    +    size_t written_size = write(fd, buf, size);

                    +    if (written_size < size) {

                    +        LOGE("Can't write [%s]", pathname);

                    +        close(fd);

                    +        return -1;

                    +    }

                    +    if (close(fd) == -1) {

                    +        LOGE("cant close [%s]", pathname);

                    +        return -1;

                    +    }

                    +    return 0;

                    +}

                    +

                    +/**

                    +* a method to Clone UI to the requested Display Id.

                    +*

                    +* Input: integer between 0 and 3

                    +* 0 - PRIMARY DISPLAY

                    +* 1 - SECONDARY DISPLAY

                    +* 2 - HDTV

                    +* 3 - pico DLP

                    +* these IDs should be in sync with overlay enums

                    +**/

                    +static void UiCloningService_CloneUiToDisplay(JNIEnv* env, jclass clazz, int displayId) {

                    +    LOGD("UiCloningService_CloneUiToDisplay : DisplayId= [%d]", displayId);

                    +

                    +    // Clone UI on Other Display

                    +    if(displayId == DISPLAYID_LCDSECONDARY|| displayId == DISPLAYID_TVHDMI) {

                    +        if (sysfile_write(overlay1ManagerEnabled, "0", sizeof("0")) < 0) {

                    +            LOGE("Failed to set overlay1/enabled = 0");

                    +            goto end;

                    +        }

                    +

                    +        if (sysfile_write(fb1Overlays, "", sizeof("")) < 0) {

                    +            LOGE("Failed to set fb1/overlays = NULL");

                    +            goto end;

                    +        }

                    +        if(displayId == DISPLAYID_LCDSECONDARY) {

                    +            if (sysfile_write(overlay1ManagerName, "2lcd", sizeof("2lcd")) < 0) {

                    +                LOGE("Failed to set overlay/manager = 2lcd");

                    +                goto end;

                    +            }

                    +        } else if(displayId == DISPLAYID_TVHDMI) {

                    +            if (sysfile_write(overlay1ManagerName, "tv", sizeof("tv")) < 0) {

                    +                LOGE("Failed to set overlay/manager = tv");

                    +                goto end;

                    +            }

                    +        }

                    +        if (sysfile_write(fb0Overlays, "0,1", sizeof("0,1")) < 0) {

                    +            LOGE("Failed to set fb0/overlays = 0,1");

                    +            goto end;

                    +        }

                    +        if (sysfile_write(fb0FitToScreenOption, "1", sizeof("1")) < 0) {

                    +            LOGE("Failed to set fb0/fit_to_screen = 1");

                    +            goto end;

                    +        }

                    +        if (sysfile_write(overlay1ManagerEnabled, "1", sizeof("1")) < 0) {

                    +            LOGE("Failed to set overlay1/enabled = 1");

                    +            goto end;

                    +        }

                    +    }

                    +    // Stop cloning UI on Other Display

                    +    else if(displayId == DISPLAYID_NONE) {

                    +        if (sysfile_write(overlay1ManagerEnabled, "0", sizeof("0")) < 0) {

                    +            LOGE("Failed to set overlay1/enabled = 0");

                    +            goto end;

                    +        }

                    +        if (sysfile_write(fb0Overlays, "0", sizeof("0")) < 0) {

                    +            LOGE("Failed to set fb0/overlays = 0");

                    +            goto end;

                    +        }

                    +        if (sysfile_write(fb0FitToScreenOption, "0", sizeof("0")) < 0) {

                    +            LOGE("Failed to set fb0/fit_to_screen = 0");

                    +            goto end;

                    +        }

                    +        if (sysfile_write(fb1Overlays, "1", sizeof("1")) < 0) {

                    +            LOGE("Failed to set fb0/overlays = 1");

                    +            goto end;

                    +        }

                    +        if (sysfile_write(overlay1ManagerName, "2lcd", sizeof("2lcd")) < 0) {

                    +            LOGE("Failed to restore overlay/manager = 2lcd");

                    +            goto end;

                    +        }

                    +    }

                    +

                    +end:

                    +    return;

                    +}

                    +

                    +// ----------------------------------------------------------------------------

                    +

                    +/*

                    + * Array of methods.

                    + *

                    + * Each entry has three fields: the name of the method, the method

                    + * signature, and a pointer to the native implementation.

                    + */

                    +static const JNINativeMethod gMethods[] = {

                    +    { "CloneUiToDisplay","(I)V", (void*)UiCloningService_CloneUiToDisplay },

                    +};

                    +

                    +/*

                    + * Explicitly register all methods for our class.

                    + *

                    + * While we're at it, cache some class references and method/field IDs.

                    + *

                    + * Returns 0 on success.

                    + */

                    +int UiCloningService_registerMethods(JNIEnv* env) {

                    +    static const char* const kClassName =

                    +        "com/ti/omap/omap_mm_library/UiCloningService";

                    +    jclass clazz;

                    +

                    +    /* look up the class */

                    +    clazz = env->FindClass(kClassName);

                    +    if (clazz == NULL) {

                    +        LOGE("Can't find class %s\n", kClassName);

                    +        return -1;

                    +    }

                    +

                    +    /* register all the methods */

                    +    if (env->RegisterNatives(clazz, gMethods,

                    +            sizeof(gMethods) / sizeof(gMethods[0])) != JNI_OK) {

                    +        LOGE("Failed registering methods for %s\n", kClassName);

                    +        return -1;

                    +    }

                    +

                    +    return 0;

                    +}

                    +

services/audioflinger/AudioFlinger.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -128,7 +128,9 @@ static bool settingsAllowed() {

                     // ----------------------------------------------------------------------------

                     AudioFlinger::AudioFlinger()

                         : BnAudioFlinger(),

                    -#ifdef HAVE_FM_RADIO

                    +#ifdef OMAP_ENHANCEMENT

                    +        mAudioHardware(0), mFmEnabled(false), mMasterVolume(1.0f), mMasterMute(false), mNextUniqueId(1)

                    +#elif defined(HAVE_FM_RADIO)

                             mAudioHardware(0), mMasterVolume(1.0f), mMasterMute(false), mNextUniqueId(1),  mFmOn(false)

                     #else

                             mAudioHardware(0), mMasterVolume(1.0f), mMasterMute(false), mNextUniqueId(1)

                    @@ -627,6 +629,11 @@ bool AudioFlinger::streamMute(int stream) const

                     bool AudioFlinger::isStreamActive(int stream) const

                     {

                         Mutex::Autolock _l(mLock);

                    +#ifdef OMAP_ENHANCEMENT

                    +      if ((mFmEnabled ) &&  (stream == AudioSystem::MUSIC)) {

                    +         return true;

                    +     }

                    +#endif

                         for (uint32_t i = 0; i < mPlaybackThreads.size(); i++) {

                             if (mPlaybackThreads.valueAt(i)->isStreamActive(stream)) {

                                 return true;

                    @@ -1088,12 +1095,19 @@ status_t AudioFlinger::ThreadBase::dumpBase(int fd, const Vector<String16>& args

                     // ----------------------------------------------------------------------------

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device)

                    +    :   ThreadBase(audioFlinger, id),

                    +        mMixBuffer(0), mSuspended(0), mBytesWritten(0), mFmInplay(false), mOutput(output),

                    +        mLastWriteTime(0), mNumWrites(0), mNumDelayedWrites(0), mInWrite(false),

                    +  mDevice(device)

                    +#else

                     AudioFlinger::PlaybackThread::PlaybackThread(const sp<AudioFlinger>& audioFlinger, AudioStreamOut* output, int id, uint32_t device)

                         :   ThreadBase(audioFlinger, id),

                             mMixBuffer(0), mSuspended(0), mBytesWritten(0), mOutput(output),

                             mLastWriteTime(0), mNumWrites(0), mNumDelayedWrites(0), mInWrite(false),

                             mDevice(device)

                    +#endif

                     {

                         readOutputParameters();

                    @@ -1504,6 +1518,15 @@ status_t AudioFlinger::PlaybackThread::getRenderPosition(uint32_t *halFrames, ui

                         return mOutput->getRenderPosition(dspFrames);

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +status_t AudioFlinger::PlaybackThread::setFMRxActive(bool state)

                    +{

                    +    LOGV("AudioFlinger::PlaybackThread::setFMRxActive(");

                    +    mFmInplay = state;

                    +    return NO_ERROR;

                    +}

                    +#endif

                    +

                     uint32_t AudioFlinger::PlaybackThread::hasAudioSession(int sessionId)

                     {

                         Mutex::Autolock _l(mLock);

                    @@ -1629,7 +1652,11 @@ bool AudioFlinger::MixerThread::threadLoop()

                                 // put audio hardware into standby after short delay

                                 if UNLIKELY((!activeTracks.size() && systemTime() > standbyTime) ||

                                             mSuspended) {

                    +#ifdef OMAP_ENHANCEMENT

                    +                if (!mStandby  && !mFmInplay){

                    +#else

                                     if (!mStandby) {

                    +#endif

                                         LOGV("Audio hardware entering standby, mixer %p, mSuspended %d\n", this, mSuspended);

                                         mOutput->standby();

                                         mStandby = true;

                    @@ -4634,6 +4661,22 @@ status_t AudioFlinger::setStreamOutput(uint32_t stream, int output)

                         return NO_ERROR;

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +status_t AudioFlinger::setFMRxActive(bool state)

                    +{

                    +     LOGV("setFMRxActive() ");

                    +    // check calling permissions

                    +    if (!settingsAllowed()) {

                    +        return PERMISSION_DENIED;

                    +    }

                    +

                    +    mFmEnabled = state;

                    +    for (uint32_t i = 0; i < mPlaybackThreads.size(); i++)

                    +       mPlaybackThreads.valueAt(i)->setFMRxActive(state);

                    +

                    +    return NO_ERROR;

                    +}

                    +#endif

                     int AudioFlinger::newAudioSessionId()

                     {

services/audioflinger/AudioFlinger.h

show inline notes
View file @ 1a6862f

            
                    @@ -108,7 +108,9 @@ public:

                         virtual     bool        getMicMute() const;

                         virtual     bool        isStreamActive(int stream) const;

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +   virtual     status_t  setFMRxActive(bool state);

                    +#endif

                         virtual     status_t    setParameters(int ioHandle, const String8& keyValuePairs);

                         virtual     String8     getParameters(int ioHandle, const String8& keys);

                    @@ -587,6 +589,9 @@ private:

                             virtual     bool        streamMute(int stream) const;

                                         bool        isStreamActive(int stream) const;

                    +#ifdef OMAP_ENHANCEMENT

                    +        virtual     status_t  setFMRxActive(bool state);

                    +#endif

                                         sp<Track>   createTrack_l(

                                                         const sp<AudioFlinger::Client>& client,

                    @@ -666,6 +671,9 @@ private:

                             int                             mSuspended;

                             int                             mBytesWritten;

                             bool                            mMasterMute;

                    +#ifdef OMAP_ENHANCEMENT

                    +        bool                            mFmInplay;

                    +#endif

                             SortedVector< wp<Track> >       mActiveTracks;

                             virtual int             getTrackName_l() = 0;

                    @@ -1180,6 +1188,9 @@ private:

                                     mutable     Mutex                   mHardwareLock;

                                     AudioHardwareInterface*             mAudioHardware;

                    +#ifdef OMAP_ENHANCEMENT

                    +                bool                                mFmEnabled;

                    +#endif

                         mutable     int                                 mHardwareStatus;

services/audioflinger/AudioPolicyService.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -594,6 +594,16 @@ status_t AudioPolicyService::setStreamOutput(AudioSystem::stream_type stream,

                         return af->setStreamOutput(stream, output);

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +status_t AudioPolicyService::setFMRxActive(bool state)

                    +{

                    +    sp<IAudioFlinger> af = AudioSystem::get_audio_flinger();

                    +    if (af == 0) return PERMISSION_DENIED;

                    +

                    +    return af->setFMRxActive(state);

                    +}

                    +#endif

                    +

                     status_t AudioPolicyService::moveEffects(int session, audio_io_handle_t srcOutput,

                                                                    audio_io_handle_t dstOutput)

                     {

                    @@ -641,12 +651,6 @@ status_t AudioPolicyService::setFmVolume(float volume, int delayMs)

                     }

                     #endif

                    -#ifdef OMAP_ENHANCEMENT

                    -status_t AudioPolicyService::setFMRxActive(bool status) {

                    -    return NO_ERROR;

                    -}

                    -#endif

                    -

                     // -----------  AudioPolicyService::AudioCommandThread implementation ----------

                     AudioPolicyService::AudioCommandThread::AudioCommandThread(String8 name)

services/audioflinger/AudioPolicyService.h

show inline notes
View file @ 1a6862f

            
                    @@ -123,6 +123,9 @@ public:

                                                          audio_io_handle_t output,

                                                          int delayMs = 0);

                         virtual status_t setStreamOutput(AudioSystem::stream_type stream, audio_io_handle_t output);

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual status_t setFMRxActive(bool state);

                    +#endif

                         virtual void setParameters(audio_io_handle_t ioHandle,

                                                    const String8& keyValuePairs,

                                                    int delayMs = 0);

                    @@ -137,10 +140,6 @@ public:

                         virtual status_t setFmVolume(float volume, int delayMs = 0);

                     #endif

                    -#ifdef OMAP_ENHANCEMENT

                    -    virtual status_t    setFMRxActive(bool status);

                    -#endif

                    -

                     private:

                                             AudioPolicyService();

                         virtual             ~AudioPolicyService();

services/camera/libcameraservice/Android.mk

show inline notes
View file @ 1a6862f

            
                    @@ -109,4 +109,12 @@ ifeq ($(TARGET_USE_MOTO_CUSTOM_CAMERA_PARAMETERS),true)

                         LOCAL_CFLAGS += -DMOTO_CUSTOM_PARAMETERS

                     endif

                    +ifeq ($(BOARD_OMAP3_WITH_FFC), true)

                    +    LOCAL_CFLAGS += -DOMAP3_SECONDARY_CAMERA

                    +endif

                    +

                    +ifeq ($(BOARD_HAS_OMAP3_FW3A_LIBCAMERA), true)

                    +    LOCAL_CFLAGS += -DOMAP3_FW3A_LIBCAMERA

                    +endif

                    +

                     include $(BUILD_SHARED_LIBRARY)

services/camera/libcameraservice/CameraService.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -99,6 +99,22 @@ static void htcCameraSwitch(int cameraId)

                     }

                     #endif

                    +#ifdef OMAP3_FW3A_LIBCAMERA

                    +static void setOmapISPReserve(int state)

                    +{

                    +    char buffer[16];

                    +    int fd;

                    +

                    +    if (access("/sys/devices/platform/omap3isp/isp_reserve", W_OK) == 0) {

                    +        snprintf(buffer, sizeof(buffer), "%d", state);

                    +

                    +        fd = open("/sys/devices/platform/omap3isp/isp_reserve", O_WRONLY);

                    +        write(fd, buffer, strlen(buffer));

                    +        close(fd);

                    +    }

                    +}

                    +#endif

                    +

                     // ----------------------------------------------------------------------------

                     // This is ugly and only safe if we never re-create the CameraService, but

                    @@ -208,13 +224,26 @@ sp<ICamera> CameraService::connect(

                     #if defined(BOARD_USE_FROYO_LIBCAMERA) || defined(BOARD_HAVE_HTC_FFC)

                         htcCameraSwitch(cameraId);

                     #endif

                    -

                         sp<CameraHardwareInterface> hardware = HAL_openCameraHardware(cameraId);

                         if (hardware == NULL) {

                             LOGE("Fail to open camera hardware (id=%d)", cameraId);

                             return NULL;

                         }

                    +#if defined(OMAP3_FW3A_LIBCAMERA) && defined(OMAP3_SECONDARY_CAMERA)

                    +    {

                    +        CameraParameters params(hardware->getParameters());

                    +        params.set("video-input", cameraId);

                    +        /* FFC doesn't export its own parameter list... :( */

                    +        if (cameraId) {

                    +            params.set("picture-size-values", "1600x1200,1280x960,1280x720,640x480,512x384,320x240"); 

                    +            params.set("focus-mode-values", "fixed");

                    +        }

                    +        hardware->setParameters(params);

                    +    }

                    +#endif

                    +

                    +

                     #if defined(BOARD_USE_REVERSE_FFC)

                         if (cameraId == 1) {

                             /* Change default parameters for the front camera */

                    @@ -388,7 +417,9 @@ void CameraService::playSound(sound_kind kind) {

                             int index;

                             AudioSystem::getStreamVolumeIndex(AudioSystem::ENFORCED_AUDIBLE, &index);

                             if (index != 0) {

                    +#ifndef OMAP_ENHANCEMENT

                                 player->seekTo(0);

                    +#endif

                                 player->start();

                             }

                         }

                    @@ -427,6 +458,13 @@ CameraService::Client::Client(const sp<CameraService>& cameraService,

                             mOverlayW = 0;

                             mOverlayH = 0;

                    +#ifdef OMAP_ENHANCEMENT

                    +  mS3DOverlay = false;

                    +#endif

                    +#ifdef OMAP3_FW3A_LIBCAMERA

                    +        setOmapISPReserve(1);

                    +#endif

                    +

                             // Callback is disabled by default

                             mPreviewCallbackFlag = FRAME_CALLBACK_FLAG_NOOP;

                             mOrientation = getOrientation(0, mCameraFacing == CAMERA_FACING_FRONT);

                    @@ -576,6 +614,9 @@ void CameraService::Client::disconnect() {

                         mHardware->cancelPicture();

                         // Release the hardware resources.

                         mHardware->release();

                    +#ifdef OMAP3_FW3A_LIBCAMERA

                    +    setOmapISPReserve(0);

                    +#endif

                         // Release the held overlay resources.

                         if (mUseOverlay) {

                     #if defined(USE_OVERLAY_FORMAT_YCbCr_420_SP) || defined(USE_OVERLAY_FORMAT_YCrCb_420_SP)

                    @@ -677,6 +718,12 @@ status_t CameraService::Client::registerPreviewBuffers() {

                     status_t CameraService::Client::setOverlay() {

                         int w, h;

                    +#ifdef OMAP_ENHANCEMENT

                    +    uint32_t overlayFormat;

                    +    bool isS3d = false;

                    +

                    +#endif

                    +

                         CameraParameters params(mHardware->getParameters());

                         params.getPreviewSize(&w, &h);

                    @@ -689,7 +736,46 @@ status_t CameraService::Client::setOverlay() {

                         }

                     #endif

                    -    if (w != mOverlayW || h != mOverlayH || mOrientationChanged) {

                    +#ifdef OMAP_ENHANCEMENT

                    +

                    +    ///Query the current preview pixel format from Camera HAL to create the overlay

                    +    ///in that particular format

                    +    const char *prevFormat = params.getPreviewFormat();

                    +#if defined(TARGET_OMAP3)

                    +    LOGD("Camera service Selected OVERLAY_FORMAT_CbYCrY_422_I");

                    +    overlayFormat = OVERLAY_FORMAT_CbYCrY_422_I;

                    +#else

                    +    if(strcmp(prevFormat, CameraParameters::PIXEL_FORMAT_YUV422I)==0)

                    +    {

                    +        LOGD("Camera service Selected OVERLAY_FORMAT_CbYCrY_422_I");

                    +        overlayFormat = OVERLAY_FORMAT_CbYCrY_422_I;

                    +    }

                    +    else if(strcmp(prevFormat, CameraParameters::PIXEL_FORMAT_YUV420SP)==0)

                    +    {

                    +        LOGD("Camera service Selected OVERLAY_FORMAT_YCbCr_420_SP");

                    +        overlayFormat = OVERLAY_FORMAT_YCbCr_420_SP;

                    +    }

                    +    else if(strcmp(prevFormat, CameraParameters::PIXEL_FORMAT_RGB565)==0)

                    +    {

                    +        LOGD("Camera service Selected OVERLAY_FORMAT_RGB_565");

                    +        overlayFormat = OVERLAY_FORMAT_RGB_565;

                    +    }

                    +    else

                    +    {

                    +        overlayFormat = OVERLAY_FORMAT_DEFAULT;

                    +    }

                    +#endif

                    +

                    +    if(params.get("s3d-supported")!= NULL && CameraParameters::TRUE != NULL)

                    +        isS3d = strcmp(params.get("s3d-supported"), CameraParameters::TRUE) == 0;

                    +#endif

                    +

                    +    if (w != mOverlayW || h != mOverlayH || mOrientationChanged

                    +#ifdef OMAP_ENHANCEMENT

                    +        || ((mOverlayFormat!=NULL) && (strcmp(prevFormat, mOverlayFormat)!=0))

                    +        || (mS3DOverlay != isS3d)

                    +#endif

                    +    ) {

                             // Force the destruction of any previous overlay

                             sp<Overlay> dummy;

                             mHardware->setOverlay(dummy);

                    @@ -700,6 +786,9 @@ status_t CameraService::Client::setOverlay() {

                             }

                     #endif

                             mOrientationChanged = false;

                    +#ifdef OMAP_ENHANCEMENT

                    +        mS3DOverlay = isS3d;

                    +#endif

                         }

                         status_t result = NO_ERROR;

                    @@ -714,6 +803,10 @@ status_t CameraService::Client::setOverlay() {

                                 // wait in the createOverlay call if the previous overlay is in the

                                 // process of being destroyed.

                                 for (int retry = 0; retry < 50; ++retry) {

                    +#ifdef OMAP_ENHANCEMENT

                    +                mOverlayRef = mSurface->createOverlay(w, h, overlayFormat,

                    +                                      mOrientation, isS3d);

                    +#else

                                     mOverlayRef = mSurface->createOverlay(w, h,

                     #if defined(USE_OVERLAY_FORMAT_YCbCr_420_SP)

                                                                           HAL_PIXEL_FORMAT_YCbCr_420_SP,

                    @@ -723,6 +816,7 @@ status_t CameraService::Client::setOverlay() {

                                                                           OVERLAY_FORMAT_DEFAULT,

                     #endif

                                                                           mOrientation);

                    +#endif

                                     if (mOverlayRef != 0) break;

                                     LOGW("Overlay create failed - retrying");

                                     usleep(20000);

                    @@ -747,6 +841,10 @@ status_t CameraService::Client::setOverlay() {

                         mOverlayW = w;

                         mOverlayH = h;

                    +#ifdef OMAP_ENHANCEMENT

                    +    strncpy(mOverlayFormat, prevFormat, OVERLAY_FORMAT_BUFFER_SIZE);

                    +#endif

                    +

                         return result;

                     }

                    @@ -812,6 +910,20 @@ status_t CameraService::Client::startPreviewMode() {

                         LOG1("startPreviewMode");

                         status_t result = NO_ERROR;

                    +#ifdef OMAP_ENHANCEMENT

                    +

                    +    //According to framework documentation, preview should be

                    +    //restarted after each capture. This will make sure

                    +    //that image capture related messages get disabled if

                    +    //not done already in their respective handlers.

                    +    disableMsgType(CAMERA_MSG_SHUTTER |

                    +                  CAMERA_MSG_POSTVIEW_FRAME |

                    +                  CAMERA_MSG_RAW_IMAGE |

                    +                  CAMERA_MSG_COMPRESSED_IMAGE |

                    +                  CAMERA_MSG_BURST_IMAGE);

                    +

                    +#endif

                    +

                         // if preview has been enabled, nothing needs to be done

                         if (mHardware->previewEnabled()) {

                             return NO_ERROR;

                    @@ -889,7 +1001,23 @@ void CameraService::Client::stopPreview() {

                         LOG1("stopPreview (pid %d)", getCallingPid());

                         Mutex::Autolock lock(mLock);

                         if (checkPidAndHardware() != NO_ERROR) return;

                    +#ifdef OMAP_ENHANCEMENT

                    +

                    +    //According to framework documentation, preview needs

                    +    //to be started for image capture. This will make sure

                    +    //that image capture related messages get disabled if

                    +    //not done already in their respective handlers.

                    +    //If these messages come when in the midddle of

                    +    //stopping preview. We will deadlock the system in

                    +    //lockIfMessageWanted()

                    +

                    +    disableMsgType(CAMERA_MSG_SHUTTER |

                    +                  CAMERA_MSG_POSTVIEW_FRAME |

                    +                  CAMERA_MSG_RAW_IMAGE |

                    +                  CAMERA_MSG_COMPRESSED_IMAGE |

                    +                  CAMERA_MSG_BURST_IMAGE);

                    +#endif

                         disableMsgType(CAMERA_MSG_PREVIEW_FRAME);

                         mHardware->stopPreview();

                    @@ -972,6 +1100,9 @@ status_t CameraService::Client::takePicture() {

                         enableMsgType(CAMERA_MSG_SHUTTER |

                                       CAMERA_MSG_POSTVIEW_FRAME |

                                       CAMERA_MSG_RAW_IMAGE |

                    +#ifdef OMAP_ENHANCEMENT

                    +                  CAMERA_MSG_BURST_IMAGE |

                    +#endif

                                       CAMERA_MSG_COMPRESSED_IMAGE);

                         return mHardware->takePicture();

                    @@ -1088,6 +1219,14 @@ bool CameraService::Client::lockIfMessageWanted(int32_t msgType) {

                                 LOG1("lockIfMessageWanted(%d): enter sleep", msgType);

                             }

                             usleep(CHECK_MESSAGE_INTERVAL * 1000);

                    +#if (defined(TARGET_OMAP3) && defined(OMAP_ENHANCEMENT))

                    +        // Return true after 100ms. We don't want to enter in an infinite loop.

                    +        if (sleepCount == 10) {

                    +            LOGE("lockIfMessageWanted(%d): timed out in %d ms",

                    +                msgType, sleepCount * CHECK_MESSAGE_INTERVAL);

                    +            return true;

                    +        }

                    +#endif

                         }

                         LOGW("lockIfMessageWanted(%d): dropped unwanted message", msgType);

                         return false;

                    @@ -1177,6 +1316,10 @@ void CameraService::Client::dataCallback(int32_t msgType,

                         if (dataPtr == 0) {

                             LOGE("Null data returned in data callback");

                             client->handleGenericNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);

                    +#if (defined(TARGET_OMAP3) && defined(OMAP_ENHANCEMENT))

                    +        //Handle the NULL data returned in RawCallback from lower layers in OMAP3

                    +        client->handleGenericData(msgType, NULL);

                    +#endif

                             return;

                         }

                    @@ -1193,14 +1336,28 @@ void CameraService::Client::dataCallback(int32_t msgType,

                             case CAMERA_MSG_COMPRESSED_IMAGE:

                                 client->handleCompressedPicture(dataPtr);

                                 break;

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +

                    +        case CAMERA_MSG_BURST_IMAGE:

                    +            client->handleBurstPicture(dataPtr);

                    +            break;

                    +

                    +#endif

                    +

                             default:

                                 client->handleGenericData(msgType, dataPtr);

                                 break;

                         }

                     }

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +void CameraService::Client::dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType,

                    +        const sp<IMemory>& dataPtr, void* user, uint32_t offset, uint32_t stride)

                    +#else

                     void CameraService::Client::dataCallbackTimestamp(nsecs_t timestamp,

                    -        int32_t msgType, const sp<IMemory>& dataPtr, void* user) {

                    +        int32_t msgType, const sp<IMemory>& dataPtr, void* user)

                    +#endif

                    +{

                         LOG2("dataCallbackTimestamp(%d)", msgType);

                         sp<Client> client = getClientFromCookie(user);

                    @@ -1212,8 +1369,11 @@ void CameraService::Client::dataCallbackTimestamp(nsecs_t timestamp,

                             client->handleGenericNotify(CAMERA_MSG_ERROR, UNKNOWN_ERROR, 0);

                             return;

                         }

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +    client->handleGenericDataTimestamp(timestamp, msgType, dataPtr, offset, stride);

                    +#else

                         client->handleGenericDataTimestamp(timestamp, msgType, dataPtr);

                    +#endif

                     }

                     // snapshot taken callback

                    @@ -1372,6 +1532,22 @@ void CameraService::Client::handleCompressedPicture(const sp<IMemory>& mem) {

                         }

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +

                    +// burst callback

                    +void CameraService::Client::handleBurstPicture(const sp<IMemory>& mem) {

                    +    //Don't disable this message type yet. In this mode takePicture() will

                    +    //get called only once. When burst finishes this message will get automatically

                    +    //disabled in the respective call for restarting the preview.

                    +

                    +    sp<ICameraClient> c = mCameraClient;

                    +    mLock.unlock();

                    +    if (c != 0) {

                    +        c->dataCallback(CAMERA_MSG_COMPRESSED_IMAGE, mem);

                    +    }

                    +}

                    +

                    +#endif

                     void CameraService::Client::handleGenericNotify(int32_t msgType,

                         int32_t ext1, int32_t ext2) {

                    @@ -1390,13 +1566,22 @@ void CameraService::Client::handleGenericData(int32_t msgType,

                             c->dataCallback(msgType, dataPtr);

                         }

                     }

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +void CameraService::Client::handleGenericDataTimestamp(nsecs_t timestamp,

                    +    int32_t msgType, const sp<IMemory>& dataPtr, uint32_t offset, uint32_t stride)

                    +#else

                     void CameraService::Client::handleGenericDataTimestamp(nsecs_t timestamp,

                    -    int32_t msgType, const sp<IMemory>& dataPtr) {

                    +    int32_t msgType, const sp<IMemory>& dataPtr)

                    +#endif

                    +{

                         sp<ICameraClient> c = mCameraClient;

                         mLock.unlock();

                         if (c != 0) {

                    +#ifdef OMAP_ENHANCEMENT

                    +        c->dataCallbackTimestamp(timestamp, msgType, dataPtr, offset, stride);

                    +#else

                             c->dataCallbackTimestamp(timestamp, msgType, dataPtr);

                    +#endif

                         }

                     }

                    @@ -1568,5 +1753,31 @@ extern "C" sp<CameraHardwareInterface> HAL_openCameraHardware(int cameraId)

                         return openCameraHardware(cameraId);

                     }

                     #endif

                    +#ifdef OMAP3_FW3A_LIBCAMERA

                    +static const CameraInfo sCameraInfo[] = {

                    +    {

                    +        CAMERA_FACING_BACK,

                    +        90,  /* orientation */

                    +    },

                    +#ifdef OMAP3_SECONDARY_CAMERA

                    +    {

                    +        CAMERA_FACING_FRONT,

                    +        270, /* orientation */

                    +    }

                    +#endif

                    +};

                    +static int getNumberOfCameras() {

                    +    return sizeof(sCameraInfo) / sizeof(sCameraInfo[0]);

                    +}

                    +

                    +extern "C" int HAL_getNumberOfCameras()

                    +{

                    +    return getNumberOfCameras();

                    +}

                    +extern "C" void HAL_getCameraInfo(int cameraId, struct CameraInfo* cameraInfo)

                    +{

                    +    memcpy(cameraInfo, &sCameraInfo[cameraId], sizeof(CameraInfo));

                    +}

                    +#endif

                     }; // namespace android

services/camera/libcameraservice/CameraService.h

show inline notes
View file @ 1a6862f

            
                    @@ -26,7 +26,15 @@

                     #include <camera/CameraHardwareInterface.h>

                     /* This needs to be increased if we can have more cameras */

                    +#ifdef OMAP_ENHANCEMENT

                    +#define MAX_CAMERAS 3

                    +#else

                     #define MAX_CAMERAS 2

                    +#endif

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +#define OVERLAY_FORMAT_BUFFER_SIZE  40

                    +#endif

                     namespace android {

                    @@ -146,7 +154,12 @@ private:

                             // these are static callback functions

                             static void             notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2, void* user);

                             static void             dataCallback(int32_t msgType, const sp<IMemory>& dataPtr, void* user);

                    +#ifdef OMAP_ENHANCEMENT

                    +        static      void        dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType,

                    +                                        const sp<IMemory>& dataPtr, void* user, uint32_t offset=0, uint32_t stride=0);

                    +#else

                             static void             dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr, void* user);

                    +#endif

                             // convert client from cookie

                             static sp<Client>       getClientFromCookie(void* user);

                             // handlers for messages

                    @@ -158,10 +171,22 @@ private:

                             void                    handlePreviewData(const sp<IMemory>& mem);

                             void                    handlePostview(const sp<IMemory>& mem);

                             void                    handleRawPicture(const sp<IMemory>& mem);

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +

                    +        void                    handleBurstPicture(const sp<IMemory>& mem);

                    +

                    +#endif

                    +

                             void                    handleCompressedPicture(const sp<IMemory>& mem);

                             void                    handleGenericNotify(int32_t msgType, int32_t ext1, int32_t ext2);

                             void                    handleGenericData(int32_t msgType, const sp<IMemory>& dataPtr);

                    +#ifdef OMAP_ENHANCEMENT

                    +        void                    handleGenericDataTimestamp(nsecs_t timestamp, int32_t msgType,

                    +                                        const sp<IMemory>& dataPtr, uint32_t offset=0, uint32_t stride=0);

                    +#else

                             void                    handleGenericDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr);

                    +#endif

                             void                    copyFrameAndPostCopiedFrame(

                                                         const sp<ICameraClient>& client,

                    @@ -214,6 +239,12 @@ private:

                             // This function keeps trying to grab mLock, or give up if the message

                             // is found to be disabled. It returns true if mLock is grabbed.

                             bool                    lockIfMessageWanted(int32_t msgType);

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +        char                     mOverlayFormat[OVERLAY_FORMAT_BUFFER_SIZE];

                    +        bool                     mS3DOverlay;

                    +#endif

                    +

                         };

                     };

services/camera/tests/CameraServiceTest/CameraServiceTest.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -297,6 +297,13 @@ public:

                         virtual void unregisterBuffers();

                         virtual sp<OverlayRef> createOverlay(

                                 uint32_t w, uint32_t h, int32_t format, int32_t orientation);

                    +#ifdef OMAP_ENHANCEMENT

                    +    virtual sp<OverlayRef> createOverlay(

                    +            uint32_t w, uint32_t h, int32_t format, int32_t orientation, int isS3D);

                    +    virtual void setDisplayId(int dpy);

                    +    virtual int requestOverlayClone(bool enable);

                    +#endif

                    +

                         virtual sp<GraphicBuffer> requestBuffer(int bufferIdx, int usage);

                         virtual status_t setBufferCount(int bufferCount);

                    @@ -372,6 +379,26 @@ sp<OverlayRef> MSurface::createOverlay(uint32_t w, uint32_t h, int32_t format,

                         return NULL;

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +sp<OverlayRef> MSurface::createOverlay(uint32_t w, uint32_t h, int32_t format,

                    +        int32_t orientation, int isS3D) {

                    +    // We don't expect this to be called in current hardware.

                    +    ASSERT(0);

                    +    sp<OverlayRef> dummy;

                    +    return dummy;

                    +}

                    +

                    +void MSurface::setDisplayId(int dpy)

                    +{

                    +return;

                    +}

                    +

                    +int MSurface::requestOverlayClone(bool enable)

                    +{

                    +return -1;

                    +}

                    +#endif

                    +

                     //

                     //  Utilities to use the Holder service

                     //

services/java/com/android/server/NotificationManagerService.java

show inline notes
View file @ 1a6862f

            
                    @@ -79,6 +79,10 @@ import java.util.HashMap;

                     import java.util.Map;

                     import java.util.Random;

                    +/* TI FM UI port -start */

                    +import android.os.SystemProperties;

                    +/* TI FM UI port -stop */

                    +

                     /** {@hide} */

                     public class NotificationManagerService extends INotificationManager.Stub

                     {

                    @@ -1135,10 +1139,24 @@ public class NotificationManagerService extends INotificationManager.Stub

                                         mSoundNotification = r;

                                         // do not play notifications if stream volume is 0

                                         // (typically because ringer mode is silent).

                    +

                                         if (audioManager.getStreamVolume(audioStreamType) != 0) {

                                             long identity = Binder.clearCallingIdentity();

                                             try {

                    +

                    +                        /* TI FM UI port -start */

                    +                        if (SystemProperties.OMAP_ENHANCEMENT) {

                    +                             Slog.d(TAG,"sending mute to fm");

                    +                            String FM_MUTE_CMD = "com.ti.server.fmmutecmd";

                    +                            // Tell the FM playback service to Mute FM,

                    +                            // as the notification playback is starting.

                    +                            // TODO: these constants need to be published somewhere in the framework

                    +                            Intent fmmute = new Intent(FM_MUTE_CMD);

                    +                            mContext.sendBroadcast(fmmute);

                                                 mSound.play(mContext, uri, looping, audioStreamType);

                    +                         }

                    +                        /* TI FM UI port -stop */

                    +

                                             }

                                             finally {

                                                 Binder.restoreCallingIdentity(identity);

                    @@ -1285,6 +1303,16 @@ public class NotificationManagerService extends INotificationManager.Stub

                                 long identity = Binder.clearCallingIdentity();

                                 try {

                                     mSound.stop();

                    +

                    +                /* TI FM UI port -start */

                    +                if (SystemProperties.OMAP_ENHANCEMENT) {

                    +                    String FM_UNMUTE_CMD = "com.ti.server.fmunmutecmd";

                    +                    /* Tell the FM playback service to unmute FM,as the notification playback is over.*/

                    +                    // TODO: these constants need to be published somewhere in the framework.

                    +                    Intent fmunmute = new Intent(FM_UNMUTE_CMD);

                    +                    mContext.sendBroadcast(fmunmute);

                    +                }

                    +                /* TI FM UI port - stop */

                                 }

                                 finally {

                                     Binder.restoreCallingIdentity(identity);

services/java/com/android/server/NotificationPlayer.java

show inline notes
View file @ 1a6862f

            
                    @@ -33,6 +33,10 @@ import java.io.IOException;

                     import java.lang.IllegalStateException;

                     import java.lang.Thread;

                     import java.util.LinkedList;

                    +import android.content.Intent;

                    +/* TI FM UI port -start */

                    +import android.os.SystemProperties;

                    +/* TI FM UI port -stop */

                     /**

                      * @hide

                    @@ -210,6 +214,18 @@ public class NotificationPlayer implements OnCompletionListener {

                         }

                         public void onCompletion(MediaPlayer mp) {

                    +

                    +        /* TI FM UI port -start */

                    +        if (SystemProperties.OMAP_ENHANCEMENT) {

                    +               String FM_UNMUTE_CMD = "com.ti.server.fmunmutecmd";

                    +               Log.v(mTag,"sending unmute to fm");

                    +               /* Tell the FM playback service to resume,as the notification playback is over*/

                    +               // TODO: these constants need to be published somewhere in the framework.

                    +               Intent fmunmute = new Intent(FM_UNMUTE_CMD);

                    +               mCompletionThread.mCmd.context.sendBroadcast(fmunmute);

                    +        }

                    +        /* TI FM UI port -stop */

                    +

                             if (mAudioManager != null) {

                                 mAudioManager.abandonAudioFocus(null);

                             }

services/sensorservice/Android.mk

show inline notes
View file @ 1a6862f

            
                    @@ -28,8 +28,11 @@ ifneq ($(TARGET_PROXIMITY_SENSOR_LIMIT),)

                         LOCAL_CFLAGS += -DPROXIMITY_LIES=$(TARGET_PROXIMITY_SENSOR_LIMIT)

                     endif

                    -ifneq ($(filter p990 p999, $(TARGET_BOOTLOADER_BOARD_NAME)),)

                    +ifneq ($(filter p990 p999 p970, $(TARGET_BOOTLOADER_BOARD_NAME)),)

                         LOCAL_CFLAGS += -DUSE_LGE_ALS_DUMMY

                    +    ifeq ($(TARGET_BOOTLOADER_BOARD_NAME),p970)

                    +        LOCAL_CFLAGS += -DUSE_LGE_ALS_OMAP3

                    +    endif

                     endif

                     # need "-lrt" on Linux simulator to pick up clock_gettime

services/sensorservice/SensorDevice.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -306,7 +306,15 @@ status_t SensorDevice::activate(void* ident, int handle, int enabled)

                             int nwr, ret, fd;

                             char value[2];

                    +#ifdef USE_LGE_ALS_OMAP3

                    +        fd = open("/sys/class/leds/lcd-backlight/als", O_RDWR);

                    +        if(fd < 0)

                    +            return -ENODEV;

                    +        nwr = sprintf(value, "%s\n", enabled ? "1" : "0");

                    +        write(fd, value, nwr);

                    +        close(fd);

                    +#else

                             fd = open("/sys/devices/platform/star_aat2870.0/lsensor_onoff", O_RDWR);

                             if(fd < 0)

                                 return -ENODEV;

                    @@ -321,6 +329,7 @@ status_t SensorDevice::activate(void* ident, int handle, int enabled)

                             nwr = sprintf(value, "%s\n", enabled ? "2" : "0");

                             write(fd, value, nwr);

                             close(fd);

                    +#endif

                             return 0;

services/surfaceflinger/Android.mk

show inline notes
View file @ 1a6862f

            
                    @@ -20,9 +20,11 @@ LOCAL_SRC_FILES:= \

                     LOCAL_CFLAGS:= -DLOG_TAG=\"SurfaceFlinger\"

                     LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES

                    +ifneq ($(OMAP_ENHANCEMENT), true)

                     ifeq ($(TARGET_BOARD_PLATFORM), omap3)

                       LOCAL_CFLAGS += -DNO_RGBX_8888

                     endif

                    +endif

                     ifeq ($(TARGET_DO_NOT_SETS_CAN_DRAW), true)

                         LOCAL_CFLAGS += -DDO_NOT_SET_CAN_DRAW

services/surfaceflinger/LayerBase.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -708,6 +708,26 @@ sp<OverlayRef> LayerBaseClient::Surface::createOverlay(

                         return NULL;

                     };

                    +#ifdef OMAP_ENHANCEMENT

                    +sp<OverlayRef> LayerBaseClient::Surface::createOverlay(

                    +        uint32_t w, uint32_t h, int32_t format, int32_t orientation, int isS3D)

                    +{

                    +    return NULL;

                    +};

                    +

                    +

                    +void LayerBaseClient::Surface::setDisplayId(int displayId)

                    +{

                    +    return;

                    +}

                    +

                    +int LayerBaseClient::Surface::requestOverlayClone(bool enable)

                    +{

                    +    return (-1);

                    +}

                    +

                    +#endif

                    +

                     // ---------------------------------------------------------------------------

                     }; // namespace android

services/surfaceflinger/LayerBase.h

show inline notes
View file @ 1a6862f

            
                    @@ -319,7 +319,12 @@ public:

                             virtual void unregisterBuffers();

                             virtual sp<OverlayRef> createOverlay(uint32_t w, uint32_t h,

                                     int32_t format, int32_t orientation);

                    -

                    +#ifdef OMAP_ENHANCEMENT

                    +        virtual sp<OverlayRef> createOverlay(uint32_t w, uint32_t h,

                    +                int32_t format, int32_t orientation, int isS3D);

                    +  virtual void setDisplayId(int displayId);

                    +        virtual int requestOverlayClone(bool enable);

                    +#endif

                         protected:

                             friend class LayerBaseClient;

                             sp<SurfaceFlinger>  mFlinger;

services/surfaceflinger/LayerBuffer.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -200,6 +200,37 @@ sp<OverlayRef> LayerBuffer::createOverlay(uint32_t w, uint32_t h, int32_t f,

                         return result;

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +sp<OverlayRef> LayerBuffer::createOverlay(uint32_t w, uint32_t h, int32_t f,

                    +        int32_t orientation, int isS3D)

                    +{

                    +    sp<OverlayRef> result;

                    +    Mutex::Autolock _l(mLock);

                    +    if (mSource != 0)

                    +        return result;

                    +    sp<OverlaySource> source = new OverlaySource(*this, &result, w, h, f, orientation, isS3D);

                    +    if (result != 0) {

                    +        mSource = source;

                    +    }

                    +    return result;

                    +}

                    +

                    +void LayerBuffer::setDisplayId(int displayId) {

                    +    sp<Source> source(getSource());

                    +    if (LIKELY(source != 0)) {

                    +        source->setDisplayId(displayId);

                    +    }

                    +}

                    +

                    +int LayerBuffer::requestOverlayClone(bool enable) {

                    +    sp<Source> source(getSource());

                    +    if (LIKELY(source != 0)) {

                    +        return (source->requestOverlayClone(enable));

                    +    }

                    +    return (-1);

                    +}

                    +#endif

                    +

                     sp<LayerBuffer::Source> LayerBuffer::getSource() const {

                         Mutex::Autolock _l(mLock);

                         return mSource;

                    @@ -260,6 +291,34 @@ sp<OverlayRef> LayerBuffer::SurfaceLayerBuffer::createOverlay(

                         return result;

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +sp<OverlayRef> LayerBuffer::SurfaceLayerBuffer::createOverlay(

                    +        uint32_t w, uint32_t h, int32_t format, int32_t orientation, int isS3D) {

                    +    sp<OverlayRef> result;

                    +    sp<LayerBuffer> owner(getOwner());

                    +    if (owner != 0)

                    +        result = owner->createOverlay(w, h, format, orientation, isS3D);

                    +    return result;

                    +}

                    +

                    +void LayerBuffer::SurfaceLayerBuffer::setDisplayId(int dpy) {

                    +    sp<LayerBuffer> owner(getOwner());

                    +    if(owner != 0)

                    +        {

                    +        owner->setDisplayId(dpy);

                    +        }

                    +}

                    +

                    +int LayerBuffer::SurfaceLayerBuffer::requestOverlayClone(bool enable) {

                    +    sp<LayerBuffer> owner(getOwner());

                    +    if(owner != 0) {

                    +        return (owner->requestOverlayClone(enable));

                    +    }

                    +    return (-1);

                    +}

                    +

                    +#endif

                    +

                     // ============================================================================

                     // LayerBuffer::Buffer

                     // ============================================================================

                    @@ -324,7 +383,14 @@ void LayerBuffer::Source::postBuffer(ssize_t offset) {

                     }

                     void LayerBuffer::Source::unregisterBuffers() {

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +void LayerBuffer::Source::setDisplayId(int dpy) {

                    +}

                    +int LayerBuffer::Source::requestOverlayClone(bool enable) {

                    +    return -1;

                    +}

                    +#endif

                     // ---------------------------------------------------------------------------

                     LayerBuffer::BufferSource::BufferSource(LayerBuffer& layer,

                    @@ -606,6 +672,23 @@ LayerBuffer::OverlaySource::OverlaySource(LayerBuffer& layer,

                         overlay_dev->setParameter(overlay_dev, overlay, 

                                 OVERLAY_DITHER, OVERLAY_ENABLE);

                    +#ifdef OMAP_ENHANCEMENT

                    +    //get the graphic plane pixel format and decide whether to use color key

                    +    //or per-pixel alpha blend

                    +    PixelFormat pixfmt = mLayer.mFlinger->getFormat();

                    +    if ((pixfmt == PIXEL_FORMAT_RGBA_8888) || (pixfmt == PIXEL_FORMAT_BGRA_8888) || \

                    +     (pixfmt == PIXEL_FORMAT_RGBA_5551) || (pixfmt == PIXEL_FORMAT_RGBA_4444))

                    +    {

                    +        overlay_dev->setParameter(overlay_dev, overlay,

                    +                              OVERLAY_COLOR_KEY,-1); //here -ve value is to disable colorkey

                    +    }

                    +    else

                    +    {

                    +        overlay_dev->setParameter(overlay_dev, overlay,

                    +              OVERLAY_COLOR_KEY, 0x00); //enabling black color key

                    +    }

                    +#endif

                    +

                         mOverlay = overlay;

                         mWidth = overlay->w;

                         mHeight = overlay->h;

                    @@ -615,6 +698,10 @@ LayerBuffer::OverlaySource::OverlaySource(LayerBuffer& layer,

                         mInitialized = false;

                         mOverlayHandle = overlay->getHandleRef(overlay);

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +    layer.dpy = 0; //initialize the Layer display ID to 0

                    +#endif

                         sp<OverlayChannel> channel = new OverlayChannel( &layer );

                    @@ -623,11 +710,72 @@ LayerBuffer::OverlaySource::OverlaySource(LayerBuffer& layer,

                         getFlinger()->signalEvent();

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +LayerBuffer::OverlaySource::OverlaySource(LayerBuffer& layer,

                    +        sp<OverlayRef>* overlayRef,

                    +        uint32_t w, uint32_t h, int32_t format, int32_t orientation, int isS3D)

                    +    : Source(layer), mVisibilityChanged(false),

                    +    mOverlay(0), mOverlayHandle(0), mOverlayDevice(0), mOrientation(orientation)

                    +{

                    +    overlay_control_device_t* overlay_dev = mLayer.mFlinger->getOverlayEngine();

                    +    if (overlay_dev == NULL) {

                    +        // overlays not supported

                    +        return;

                    +    }

                    +    mOverlayDevice = overlay_dev;

                    +    overlay_t* overlay = overlay_dev->createOverlay_S3D(overlay_dev, w, h, format, isS3D);

                    +    if (overlay == NULL) {

                    +        // couldn't create the overlay (no memory? no more overlays?)

                    +        return;

                    +    }

                    +

                    +    // enable dithering...

                    +    overlay_dev->setParameter(overlay_dev, overlay,

                    +            OVERLAY_DITHER, OVERLAY_ENABLE);

                    +

                    +    //get the graphic plane pixel format and decide whether to use color key

                    +    //or per-pixel alpha blend

                    +    PixelFormat pixfmt = mLayer.mFlinger->getFormat();

                    +    if ((pixfmt == PIXEL_FORMAT_RGBA_8888) || (pixfmt == PIXEL_FORMAT_BGRA_8888) || \

                    +     (pixfmt == PIXEL_FORMAT_RGBA_5551) || (pixfmt == PIXEL_FORMAT_RGBA_4444))

                    +    {

                    +         overlay_dev->setParameter(overlay_dev, overlay,

                    +                              OVERLAY_COLOR_KEY,-1); //here -ve value is to disable colorkey

                    +    }

                    +    else

                    +    {

                    +        overlay_dev->setParameter(overlay_dev, overlay,

                    +              OVERLAY_COLOR_KEY, 0x00); //enabling black color key

                    +    }

                    +

                    +    mOverlay = overlay;

                    +    mWidth = overlay->w;

                    +    mHeight = overlay->h;

                    +    mFormat = overlay->format;

                    +    mWidthStride = overlay->w_stride;

                    +    mHeightStride = overlay->h_stride;

                    +    mInitialized = false;

                    +

                    +    mOverlayHandle = overlay->getHandleRef(overlay);

                    +

                    +    layer.dpy = 0; //initialize the Layer display ID to 0

                    +

                    +    sp<OverlayChannel> channel = new OverlayChannel( &layer );

                    +

                    +    *overlayRef = new OverlayRef(mOverlayHandle, channel,

                    +            mWidth, mHeight, mFormat, mWidthStride, mHeightStride);

                    +    mLayer.mFlinger->signalEvent();

                    +}

                    +#endif

                    +

                     LayerBuffer::OverlaySource::~OverlaySource()

                     {

                         if (mOverlay && mOverlayDevice) {

                             overlay_control_device_t* overlay_dev = mOverlayDevice;

                             overlay_dev->destroyOverlay(overlay_dev, mOverlay);

                    +#ifdef OMAP_ENHANCEMENT

                    +        mOverlay = 0;

                    +#endif

                         }

                     }

                    @@ -654,6 +802,36 @@ void LayerBuffer::OverlaySource::onvalidateVisibility(const Transform&)

                         mVisibilityChanged = true;

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +void LayerBuffer::OverlaySource::setDisplayId(int displayId) {

                    +    if (UNLIKELY(mOverlay != 0)) {

                    +        // we need a lock here to protect "destroy"

                    +        Mutex::Autolock _l(mOverlaySourceLock);

                    +        if (mOverlay) {

                    +            overlay_control_device_t* overlay_dev = mOverlayDevice;

                    +            mLayer.dpy = displayId;

                    +            overlay_dev->setParameter(overlay_dev, mOverlay,

                    +                                    OVERLAY_SET_SCREEN_ID, mLayer.dpy);

                    +            overlay_dev->commit(overlay_dev, mOverlay);

                    +        }

                    +    }

                    +}

                    +

                    +int LayerBuffer::OverlaySource::requestOverlayClone(bool enable) {

                    +    if (UNLIKELY(mOverlay != 0)) {

                    +        //we need a lock here to protect "destroy"

                    +        Mutex::Autolock _l(mOverlaySourceLock);

                    +        if (mOverlay) {

                    +            overlay_control_device_t* overlay_dev = mOverlayDevice;

                    +            int overlayclonefd = overlay_dev->requestOverlayClone(overlay_dev, mOverlay, (int)enable);

                    +            return overlayclonefd;

                    +        }

                    +    }

                    +    return (-1);

                    +}

                    +

                    +#endif

                    +

                     void LayerBuffer::OverlaySource::onVisibilityResolved(

                             const Transform& planeTransform)

                     {

                    @@ -680,6 +858,16 @@ void LayerBuffer::OverlaySource::onVisibilityResolved(

                                             Transform(mOrientation));

                                     overlay_dev->setParameter(overlay_dev, mOverlay,

                                             OVERLAY_TRANSFORM, finalTransform.getOrientation());

                    +#ifdef OMAP_ENHANCEMENT

                    +                //get the current state of the layer: to commit the latest parameters

                    +                State& layerSt = mLayer.currentState();

                    +                overlay_dev->setParameter(overlay_dev, mOverlay,

                    +                        OVERLAY_PLANE_ALPHA, layerSt.alpha);

                    +                overlay_dev->setParameter(overlay_dev, mOverlay,

                    +                        OVERLAY_PLANE_Z_ORDER, layerSt.z);

                    +                overlay_dev->setParameter(overlay_dev, mOverlay,

                    +                OVERLAY_SET_SCREEN_ID, mLayer.dpy);

                    +#endif

                                     overlay_dev->commit(overlay_dev, mOverlay);

                                 }

                             }

services/surfaceflinger/LayerBuffer.h

show inline notes
View file @ 1a6862f

            
                    @@ -49,6 +49,10 @@ class LayerBuffer : public LayerBaseClient

                             virtual void unregisterBuffers();

                             virtual void destroy() { }

                             SurfaceFlinger* getFlinger() const { return mLayer.mFlinger.get(); }

                    +#ifdef OMAP_ENHANCEMENT

                    +        virtual void setDisplayId(int dpy);

                    +        virtual int requestOverlayClone(bool enable);

                    +#endif

                         protected:

                             LayerBuffer& mLayer;

                         };

                    @@ -75,7 +79,13 @@ public:

                         void unregisterBuffers();

                         sp<OverlayRef> createOverlay(uint32_t w, uint32_t h, int32_t format,

                                 int32_t orientation);

                    -    

                    +#ifdef OMAP_ENHANCEMENT

                    +    sp<OverlayRef> createOverlay(uint32_t w, uint32_t h, int32_t format,

                    +            int32_t orientation, int isS3D);

                    +

                    +    void setDisplayId(int displayId);

                    +    int requestOverlayClone(bool enable);

                    +#endif

                         sp<Source> getSource() const;

                         sp<Source> clearSource();

                         void setNeedsBlending(bool blending);

                    @@ -151,6 +161,14 @@ private:

                             OverlaySource(LayerBuffer& layer,

                                     sp<OverlayRef>* overlayRef, 

                                     uint32_t w, uint32_t h, int32_t format, int32_t orientation);

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +        OverlaySource(LayerBuffer& layer,

                    +                sp<OverlayRef>* overlayRef,

                    +                uint32_t w, uint32_t h, int32_t format, int32_t orientation, int isS3D);

                    +        virtual void setDisplayId(int dpy);

                    +        int requestOverlayClone(bool enable);

                    +#endif

                             virtual ~OverlaySource();

                             virtual void onDraw(const Region& clip) const;

                             virtual void onTransaction(uint32_t flags);

                    @@ -203,6 +221,13 @@ private:

                             virtual sp<OverlayRef> createOverlay(

                                     uint32_t w, uint32_t h, int32_t format, int32_t orientation);

                    +

                    +#ifdef OMAP_ENHANCEMENT

                    +        virtual sp<OverlayRef> createOverlay(

                    +                uint32_t w, uint32_t h, int32_t format, int32_t orientation, int isS3D);

                    +        virtual void setDisplayId(int displayId);

                    +        virtual int requestOverlayClone(bool enable);

                    +#endif

                         private:

                             sp<LayerBuffer> getOwner() const {

                                 return static_cast<LayerBuffer*>(Surface::getOwner().get());

services/surfaceflinger/SurfaceFlinger.cpp

show inline notes
View file @ 1a6862f

            
                    @@ -152,6 +152,13 @@ overlay_control_device_t* SurfaceFlinger::getOverlayEngine() const

                         return graphicPlane(0).displayHardware().getOverlayEngine();

                     }

                    +#ifdef OMAP_ENHANCEMENT

                    +PixelFormat SurfaceFlinger::getFormat() const

                    +{

                    +    return graphicPlane(0).displayHardware().getFormat();

                    +}

                    +#endif

                    +

                     sp<IMemoryHeap> SurfaceFlinger::getCblk() const

                     {

                         return mServerHeap;

                    @@ -410,7 +417,9 @@ bool SurfaceFlinger::threadLoop()

                     #ifdef USE_COMPOSITION_BYPASS

                             if (handleBypassLayer()) {

                    +#ifndef OMAP_ENHANCEMENT

                                 unlockClients();

                    +#endif

                                 return true;

                             }

                     #endif

services/surfaceflinger/SurfaceFlinger.h

show inline notes
View file @ 1a6862f

            
                    @@ -227,6 +227,9 @@ public:

                         void destroyLayer(LayerBase const* layer);

                         sp<Layer> getLayer(const sp<ISurface>& sur) const;

                    +#ifdef OMAP_ENHANCEMENT

                    +    PixelFormat getFormat() const;

                    +#endif

                     private:

                         friend class Client;

0 notes on commit `1a6862f` Show line notes below

Email notifications for these commit notes are on. Disable email notifications for this commit

CyanogenMod / android_frameworks_base forked from KellyMahan/android_frameworks_base

Jump to Line

0 notes on commit `1a6862f` Show line notes below

GitHub Links

GitHub

Tools

Extras

Documentation

Keyboard Shortcuts (see all)

Site wide shortcuts

Commit list

Pull request list

Issues

Issues Dashboard

Network Graph

Source Code Browsing

Markdown Cheat Sheet

Format Text

Lists

Miscellaneous

Code Examples in Markdown

...	...	@@ -2763,6 +2763,10 @@ public class Camera {
2763	2763	/* Support NV cams */
2764	2764	KEY_ISO_MODE = "nv-picture-iso";
2765	2765	str = get(KEY_ISO_MODE + SUPPORTED_VALUES_SUFFIX);
	2766	+ } else if (str == null && get("iso-mode-values") != null) {
	2767	+ /* Support OMAP cams */
	2768	+ KEY_ISO_MODE = "iso-mode";
	2769	+ str = get(KEY_ISO_MODE + SUPPORTED_VALUES_SUFFIX);
2766	2770	}
2767	2771	return split(str);
2768	2772	}

...	...	@@ -28,6 +28,7 @@ public class SystemProperties
28	28	{
29	29	public static final int PROP_NAME_MAX = 31;
30	30	public static final int PROP_VALUE_MAX = 91;
	31	+ public static final boolean OMAP_ENHANCEMENT = native_get_boolean("com.ti.omap_enhancement", false);
31	32
32	33	private static native String native_get(String key);
33	34	private static native String native_get(String key, String def);

...	...	@@ -35,10 +35,20 @@ import android.view.SurfaceHolder;
35	35	import android.view.SurfaceView;
36	36	import android.view.View;
37	37	import android.widget.MediaController.MediaPlayerControl;
	38	+import android.content.BroadcastReceiver;
	39	+import android.content.IntentFilter;
	40	+import android.os.SystemProperties;
38	41
39	42	import java.io.IOException;
40	43	import java.util.Map;
41	44
	45	+/* TI custom package */
	46	+import com.ti.omap.omap_mm_library.OmapMMLibrary;
	47	+
	48	+/* TI FM UI port -start */
	49	+import android.os.SystemProperties;
	50	+/* TI FM UI port -stop */
	51	+
42	52	/**
43	53	* Displays a video file. The VideoView class
44	54	* can load images from various sources (such as resources or content
...	...	@@ -48,6 +58,10 @@ import java.util.Map;
48	58	*/
49	59	public class VideoView extends SurfaceView implements MediaPlayerControl {
50	60	private String TAG = "VideoView";
	61	+
	62	+ private OmapMMLibrary mOmapMMHandle = null;
	63	+ private IntentFilter mHdmiIntent = null;
	64	+
51	65	// settable by the client
52	66	private Uri mUri;
53	67	private Map<String, String> mHeaders;
...	...	@@ -65,6 +79,12 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {
65	79	private static final int STATE_RESUME = 7;
66	80	private static final int STATE_SUSPEND_UNSUPPORTED = 8;
67	81
	82	+ // All possible Display Types on OMAP4.
	83	+ private static final int DISPLAY_TYPE_LCD_PRIMARY = 0x0000;
	84	+ private static final int DISPLAY_TYPE_LCD_SECONDARY = 0x0001;
	85	+ private static final int DISPLAY_TYPE_HDMI_TV = 0x0002;
	86	+ private static final int DISPLAY_TYPE_PICO_DLP = 0x0003;
	87	+
68	88	// mCurrentState is a VideoView object's current state.
69	89	// mTargetState is the state that a method caller intends to reach.
70	90	// For instance, regardless the VideoView object's current state,
...	...	@@ -91,6 +111,10 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {
91	111	private boolean mCanSeekForward;
92	112	private int mStateWhenSuspended; //state before calling suspend()
93	113
	114	+ private static final String ACTION_HDMI_PLUG = "android.intent.action.HDMI_PLUG";
	115	+ // Broadcast receiver for device connections intent broadcasts
	116	+ private final BroadcastReceiver mReceiver = new VideoPlaybackBroadcastReceiver();
	117	+
94	118	public VideoView(Context context) {
95	119	super(context);
96	120	initVideoView();
...	...	@@ -167,6 +191,14 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {
167	191	requestFocus();
168	192	mCurrentState = STATE_IDLE;
169	193	mTargetState = STATE_IDLE;
	194	+
	195	+ if(SystemProperties.OMAP_ENHANCEMENT) {
	196	+ mOmapMMHandle = new OmapMMLibrary();
	197	+ //if the OmapMMHandle is non-null, initialise jni
	198	+ if (mOmapMMHandle != null) {
	199	+ mOmapMMHandle.native_init();
	200	+ }
	201	+ }
170	202	}
171	203
172	204	public void setVideoPath(String path) {
...	...	@@ -197,6 +229,19 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {
197	229	mCurrentState = STATE_IDLE;
198	230	mTargetState = STATE_IDLE;
199	231	}
	232	+
	233	+ // Unregister for device HDMI-Hotplug intent broadcasts.
	234	+ if(SystemProperties.OMAP_ENHANCEMENT) {
	235	+ //unregister and delete the memory for hdmi intent
	236	+ if (mHdmiIntent != null) {
	237	+ mContext.unregisterReceiver(mReceiver);
	238	+ mHdmiIntent = null;
	239	+ }
	240	+ //delete the omapMMHandle memory
	241	+ if (mOmapMMHandle != null) {
	242	+ mOmapMMHandle = null;
	243	+ }
	244	+ }
200	245	}
201	246
202	247	private void openVideo() {
...	...	@@ -209,7 +254,14 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {
209	254	Intent i = new Intent("com.android.music.musicservicecommand");
210	255	i.putExtra("command", "pause");
211	256	mContext.sendBroadcast(i);
212		-
	257	+ /* TI FM UI port -start */
	258	+ if (SystemProperties.OMAP_ENHANCEMENT) {
	259	+ // Tell the FM playback service to pause,as the video playback will start.
	260	+ // TODO: these constants need to be published somewhere in the framework.
	261	+ Intent fm = new Intent("com.ti.server.fmpausecmd");
	262	+ mContext.sendBroadcast(fm);
	263	+ }
	264	+ /* TI FM UI port -stop */
213	265	// we shouldn't clear the target state, because somebody might have
214	266	// called start() previously
215	267	release(false);
...	...	@@ -231,6 +283,10 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {
231	283	// target state that was there before.
232	284	mCurrentState = STATE_PREPARING;
233	285	attachMediaController();
	286	+ if(SystemProperties.OMAP_ENHANCEMENT) {
	287	+ mOmapMMHandle.setVideoSurface(mSurfaceHolder);
	288	+ mOmapMMHandle.setMediaPlayer(mMediaPlayer);
	289	+ }
234	290	} catch (IOException ex) {
235	291	Log.w(TAG, "Unable to open content: " + mUri, ex);
236	292	mCurrentState = STATE_ERROR;
...	...	@@ -278,7 +334,16 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {
278	334	MediaPlayer.OnPreparedListener mPreparedListener = new MediaPlayer.OnPreparedListener() {
279	335	public void onPrepared(MediaPlayer mp) {
280	336	mCurrentState = STATE_PREPARED;
281		-
	337	+ /**
	338	+ * Register for device HDMI-Hotplug intent broadcasts.
	339	+ * the registration is delayed till the Media player is prepared.
	340	+ * This is required to avoid the scenario where the event is disptached
	341	+ * even before Overlay source is created.
	342	+ */
	343	+ if(SystemProperties.OMAP_ENHANCEMENT) {
	344	+ mHdmiIntent = new IntentFilter(ACTION_HDMI_PLUG);
	345	+ mContext.registerReceiver(mReceiver, mHdmiIntent);
	346	+ }
282	347	// Get the capabilities of the player for this stream
283	348	Metadata data = mp.getMetadata(MediaPlayer.METADATA_ALL,
284	349	MediaPlayer.BYPASS_METADATA_FILTER);
...	...	@@ -477,6 +542,9 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {
477	542	if (mMediaPlayer != null && mCurrentState == STATE_SUSPEND
478	543	&& mTargetState == STATE_RESUME) {
479	544	mMediaPlayer.setDisplay(mSurfaceHolder);
	545	+ if(SystemProperties.OMAP_ENHANCEMENT) {
	546	+ mOmapMMHandle.setVideoSurface(mSurfaceHolder);
	547	+ }
480	548	resume();
481	549	} else {
482	550	openVideo();
...	...	@@ -606,6 +674,12 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {
606	674	if (mMediaPlayer.resume()) {
607	675	mCurrentState = mStateWhenSuspended;
608	676	mTargetState = mStateWhenSuspended;
	677	+ if(SystemProperties.OMAP_ENHANCEMENT) {
	678	+ Intent hdmiIntent = mContext.registerReceiver(null,
	679	+ new IntentFilter(ACTION_HDMI_PLUG));
	680	+ mReceiver.onReceive(mContext, hdmiIntent);
	681	+ }
	682	+
609	683	} else {
610	684	Log.w(TAG, "Unable to resume video");
611	685	}
...	...	@@ -674,4 +748,31 @@ public class VideoView extends SurfaceView implements MediaPlayerControl {
674	748	public boolean canSeekForward() {
675	749	return mCanSeekForward;
676	750	}
	751	+
	752	+ /**
	753	+ * Receiver for HDMI-Hotplug intent broadcasts
	754	+ */
	755	+ private class VideoPlaybackBroadcastReceiver extends BroadcastReceiver {
	756	+ @Override
	757	+ public void onReceive(Context context, Intent intent) {
	758	+ if (intent == null) {
	759	+ Log.e(TAG, "VideoPlaybackBroadcastReceiver intent is NULL!");
	760	+ return;
	761	+ }
	762	+ String action = intent.getAction();
	763	+
	764	+ if (SystemProperties.OMAP_ENHANCEMENT && action.equals(ACTION_HDMI_PLUG)) {
	765	+ int state = intent.getIntExtra("state", 0);
	766	+
	767	+ if(state==1) {
	768	+ Log.d(TAG, "VideoPlaybackBroadcastReceiver.onReceive() : Switching to HDMI_TV)");
	769	+ mOmapMMHandle.setDisplayId(DISPLAY_TYPE_HDMI_TV);
	770	+ } else {
	771	+ Log.d(TAG, "VideoPlaybackBroadcastReceiver.onReceive() : Switching to LCD-Primary");
	772	+ mOmapMMHandle.setDisplayId(DISPLAY_TYPE_LCD_PRIMARY);
	773	+ }
	774	+ }
	775	+ }
	776	+ }
	777	+
677	778	}

...	...	@@ -50,7 +50,11 @@ public:
50	50	~JNICameraContext() { release(); }
51	51	virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2);
52	52	virtual void postData(int32_t msgType, const sp<IMemory>& dataPtr);
	53	+#ifdef OMAP_ENHANCEMENT
	54	+ virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr, uint32_t offset=0, uint32_t stride=0);
	55	+#else
53	56	virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr);
	57	+#endif
54	58	void addCallbackBuffer(JNIEnv *env, jbyteArray cbb);
55	59	void setCallbackMode(JNIEnv *env, bool installed, bool manualMode);
56	60	sp<Camera> getCamera() { Mutex::Autolock _l(mLock); return mCamera; }
...	...	@@ -227,8 +231,12 @@ void JNICameraContext::postData(int32_t msgType, const sp<IMemory>& dataPtr)
227	231	break;
228	232	}
229	233	}
230		-
	234	+#ifdef OMAP_ENHANCEMENT
	235	+void JNICameraContext::postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr,
	236	+ uint32_t offset, uint32_t stride)
	237	+#else
231	238	void JNICameraContext::postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr)
	239	+#endif
232	240	{
233	241	// TODO: plumb up to Java. For now, just drop the timestamp
234	242	postData(msgType, dataPtr);

...	...	@@ -78,6 +78,13 @@ enum {
78	78	CAMERA_MSG_POSTVIEW_FRAME = 0x040,
79	79	CAMERA_MSG_RAW_IMAGE = 0x080,
80	80	CAMERA_MSG_COMPRESSED_IMAGE = 0x100,
	81	+
	82	+#ifdef OMAP_ENHANCEMENT
	83	+
	84	+ CAMERA_MSG_BURST_IMAGE = 0x200,
	85	+
	86	+#endif
	87	+
81	88	CAMERA_MSG_ALL_MSGS = 0x1FF
82	89	};
83	90
...	...	@@ -146,7 +153,12 @@ class CameraListener: virtual public RefBase
146	153	public:
147	154	virtual void notify(int32_t msgType, int32_t ext1, int32_t ext2) = 0;
148	155	virtual void postData(int32_t msgType, const sp<IMemory>& dataPtr) = 0;
	156	+#ifdef OMAP_ENHANCEMENT
	157	+ virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr,
	158	+ uint32_t offset=0, uint32_t stride=0) = 0;
	159	+#else
149	160	virtual void postDataTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr) = 0;
	161	+#endif
150	162	};
151	163
152	164	class Camera : public BnCameraClient, public IBinder::DeathRecipient
...	...	@@ -232,7 +244,12 @@ public:
232	244	// ICameraClient interface
233	245	virtual void notifyCallback(int32_t msgType, int32_t ext, int32_t ext2);
234	246	virtual void dataCallback(int32_t msgType, const sp<IMemory>& dataPtr);
	247	+#ifdef OMAP_ENHANCEMENT
	248	+ virtual void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr,
	249	+ uint32_t offset=0, uint32_t stride=0);
	250	+#else
235	251	virtual void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr);
	252	+#endif
236	253
237	254	sp<ICamera> remote();
238	255

...	...	@@ -46,12 +46,19 @@ typedef void (*notify_callback)(int32_t msgType,
46	46	typedef void (*data_callback)(int32_t msgType,
47	47	const sp<IMemory>& dataPtr,
48	48	void* user);
49		-
	49	+#ifdef OMAP_ENHANCEMENT
	50	+typedef void (*data_callback_timestamp)(nsecs_t timestamp,
	51	+ int32_t msgType,
	52	+ const sp<IMemory>& dataPtr,
	53	+ void* user,
	54	+ uint32_t offset,
	55	+ uint32_t stride);
	56	+#else
50	57	typedef void (*data_callback_timestamp)(nsecs_t timestamp,
51	58	int32_t msgType,
52	59	const sp<IMemory>& dataPtr,
53	60	void* user);
54		-
	61	+#endif
55	62	/**
56	63	* CameraHardwareInterface.h defines the interface to the
57	64	* camera hardware abstraction layer, used for setting and getting

...	...	@@ -32,7 +32,12 @@ public:
32	32
33	33	virtual void notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2) = 0;
34	34	virtual void dataCallback(int32_t msgType, const sp<IMemory>& data) = 0;
	35	+#ifdef OMAP_ENHANCEMENT
	36	+ virtual void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& data,
	37	+ uint32_t offset=0, uint32_t stride=0) = 0;
	38	+#else
35	39	virtual void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& data) = 0;
	40	+#endif
36	41	};
37	42
38	43	// ----------------------------------------------------------------------------

...	...	@@ -145,12 +145,19 @@ public:
145	145	CHANNEL_IN_Z_AXIS = 0x2000,
146	146	CHANNEL_IN_VOICE_UPLINK = 0x4000,
147	147	CHANNEL_IN_VOICE_DNLINK = 0x8000,
	148	+#ifdef OMAP_ENHANCEMENT
	149	+ CHANNEL_IN_VOICE_UPLINK_DNLINK = 0x10000,
	150	+#endif
148	151	CHANNEL_IN_MONO = CHANNEL_IN_FRONT,
149	152	CHANNEL_IN_STEREO = (CHANNEL_IN_LEFT \| CHANNEL_IN_RIGHT),
150	153	CHANNEL_IN_ALL = (CHANNEL_IN_LEFT \| CHANNEL_IN_RIGHT \| CHANNEL_IN_FRONT \| CHANNEL_IN_BACK\|
151	154	CHANNEL_IN_LEFT_PROCESSED \| CHANNEL_IN_RIGHT_PROCESSED \| CHANNEL_IN_FRONT_PROCESSED \| CHANNEL_IN_BACK_PROCESSED\|
152	155	CHANNEL_IN_PRESSURE \| CHANNEL_IN_X_AXIS \| CHANNEL_IN_Y_AXIS \| CHANNEL_IN_Z_AXIS \|
153		- CHANNEL_IN_VOICE_UPLINK \| CHANNEL_IN_VOICE_DNLINK)
	156	+#ifdef OMAP_ENHANCEMENT
	157	+ CHANNEL_IN_VOICE_UPLINK \| CHANNEL_IN_VOICE_DNLINK \| CHANNEL_IN_VOICE_UPLINK_DNLINK)
	158	+#else
	159	+ CHANNEL_IN_VOICE_UPLINK \| CHANNEL_IN_VOICE_DNLINK )
	160	+#endif
154	161	};
155	162
156	163	enum audio_mode {
...	...	@@ -269,12 +276,15 @@ public:
269	276	DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES = 0x100,
270	277	DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER = 0x200,
271	278	DEVICE_OUT_AUX_DIGITAL = 0x400,
272		- DEVICE_OUT_HDMI = 0x2000,
273	279	#ifdef HAVE_FM_RADIO
274	280	DEVICE_OUT_FM = 0x800,
275	281	DEVICE_OUT_FM_SPEAKER = 0x1000,
276	282	DEVICE_OUT_FM_ALL = (DEVICE_OUT_FM \| DEVICE_OUT_FM_SPEAKER),
	283	+#elif defined(OMAP_ENHANCEMENT)
	284	+ DEVICE_OUT_FM_TRANSMIT = 0x800,
	285	+ DEVICE_OUT_LOW_POWER = 0x1000,
277	286	#endif
	287	+ DEVICE_OUT_HDMI = 0x2000,
278	288	DEVICE_OUT_DEFAULT = 0x8000,
279	289	DEVICE_OUT_ALL = (DEVICE_OUT_EARPIECE \| DEVICE_OUT_SPEAKER \| DEVICE_OUT_WIRED_HEADSET \|
280	290	#ifdef HAVE_FM_RADIO
...	...	@@ -283,7 +293,12 @@ public:
283	293	DEVICE_OUT_WIRED_HEADPHONE \| DEVICE_OUT_BLUETOOTH_SCO \| DEVICE_OUT_BLUETOOTH_SCO_HEADSET \|
284	294	#endif
285	295	DEVICE_OUT_BLUETOOTH_SCO_CARKIT \| DEVICE_OUT_BLUETOOTH_A2DP \| DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES \|
	296	+#ifdef OMAP_ENHANCEMENT
	297	+ DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER \| DEVICE_OUT_AUX_DIGITAL \| DEVICE_OUT_LOW_POWER \|
	298	+ DEVICE_OUT_FM_TRANSMIT \| DEVICE_OUT_DEFAULT),
	299	+#else
286	300	DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER \| DEVICE_OUT_AUX_DIGITAL \| DEVICE_OUT_HDMI \| DEVICE_OUT_DEFAULT),
	301	+#endif
287	302	DEVICE_OUT_ALL_A2DP = (DEVICE_OUT_BLUETOOTH_A2DP \| DEVICE_OUT_BLUETOOTH_A2DP_HEADPHONES \|
288	303	DEVICE_OUT_BLUETOOTH_A2DP_SPEAKER),
289	304
...	...	@@ -300,12 +315,17 @@ public:
300	315	DEVICE_IN_FM_RX = 0x1000000,
301	316	DEVICE_IN_FM_RX_A2DP = 0x2000000,
302	317	#endif
	318	+#ifdef OMAP_ENHANCEMENT
	319	+ DEVICE_IN_FM_ANALOG = 0x1000000,
	320	+#endif
303	321	DEVICE_IN_DEFAULT = 0x80000000,
304	322
305	323	DEVICE_IN_ALL = (DEVICE_IN_COMMUNICATION \| DEVICE_IN_AMBIENT \| DEVICE_IN_BUILTIN_MIC \|
306	324	DEVICE_IN_BLUETOOTH_SCO_HEADSET \| DEVICE_IN_WIRED_HEADSET \| DEVICE_IN_AUX_DIGITAL \|
307	325	#ifdef HAVE_FM_RADIO
308	326	DEVICE_IN_VOICE_CALL \| DEVICE_IN_BACK_MIC \| DEVICE_IN_FM_RX \| DEVICE_IN_FM_RX_A2DP \| DEVICE_IN_DEFAULT)
	327	+#elif OMAP_ENHANCEMENT
	328	+ DEVICE_IN_VOICE_CALL \| DEVICE_IN_BACK_MIC \| DEVICE_IN_FM_ANALOG \| DEVICE_IN_DEFAULT)
309	329	#else
310	330	DEVICE_IN_VOICE_CALL \| DEVICE_IN_BACK_MIC \| DEVICE_IN_DEFAULT)
311	331	#endif

...	...	@@ -91,7 +91,12 @@ public:
91	91	*/
92	92	virtual status_t setStreamVolume(int stream, float value, int output) = 0;
93	93	virtual status_t setStreamMute(int stream, bool muted) = 0;
94		-
	94	+#ifdef OMAP_ENHANCEMENT
	95	+ /* This will tell playback thread that FM Rx is active
	96	+ * and device will not go to standby
	97	+ */
	98	+ virtual status_t setFMRxActive(bool state)=0;
	99	+#endif
95	100	virtual float streamVolume(int stream, int output) const = 0;
96	101	virtual bool streamMute(int stream) const = 0;
97	102

...	...	@@ -51,6 +51,9 @@ public:
51	51	virtual status_t setAuxEffectSendLevel(float level) = 0;
52	52	virtual status_t attachAuxEffect(int effectId) = 0;
53	53
	54	+#ifdef OMAP_ENHANCEMENT
	55	+ virtual status_t requestVideoCloneMode(bool enable) = 0;
	56	+#endif
54	57	// Invoke a generic method on the player by using opaque parcels
55	58	// for the request and reply.
56	59	// @param request Parcel that must start with the media player

...	...	@@ -32,6 +32,9 @@ namespace android {
32	32
33	33	class IMediaRecorder;
34	34	class IOMX;
	35	+#ifdef OMAP_ENHANCEMENT
	36	+class IOverlayRenderer;
	37	+#endif
35	38
36	39	class IMediaPlayerService: public IInterface
37	40	{
...	...	@@ -48,6 +51,9 @@ public:
48	51	virtual sp<IMemory> decode(const char* url, uint32_t pSampleRate, int pNumChannels, int* pFormat) = 0;
49	52	virtual sp<IMemory> decode(int fd, int64_t offset, int64_t length, uint32_t pSampleRate, int pNumChannels, int* pFormat) = 0;
50	53	virtual sp<IOMX> getOMX() = 0;
	54	+#ifdef OMAP_ENHANCEMENT
	55	+ virtual sp<IOverlayRenderer> getOverlayRenderer()=0;
	56	+#endif
51	57	};
52	58
53	59	// ----------------------------------------------------------------------------

...	...	@@ -137,6 +137,29 @@ public:
137	137	size_t encodedWidth, size_t encodedHeight,
138	138	size_t displayWidth, size_t displayHeight,
139	139	int32_t rotationDegrees);
	140	+
	141	+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)
	142	+ virtual status_t useBuffer(
	143	+ node_id node, OMX_U32 port_index, const sp<IMemory> &params,
	144	+ buffer_id *buffer, size_t size) = 0;
	145	+#endif
	146	+
	147	+#ifdef OMAP_ENHANCEMENT
	148	+ sp<IOMXRenderer> createRenderer(
	149	+ const sp<Surface> &surface,
	150	+ const char *componentName,
	151	+ OMX_COLOR_FORMATTYPE colorFormat,
	152	+ size_t encodedWidth, size_t encodedHeight,
	153	+ size_t displayWidth, size_t displayHeight, int32_t rotation, int isS3D, int numOfOpBuffers = -1);
	154	+
	155	+ virtual sp<IOMXRenderer> createRenderer(
	156	+ const sp<ISurface> &surface,
	157	+ const char *componentName,
	158	+ OMX_COLOR_FORMATTYPE colorFormat,
	159	+ size_t encodedWidth, size_t encodedHeight,
	160	+ size_t displayWidth, size_t displayHeight, int32_t rotation, int isS3D, int numOfOpBuffers = -1) = 0;
	161	+
	162	+#endif
140	163	};
141	164
142	165	struct omx_message {
...	...	@@ -144,7 +167,9 @@ struct omx_message {
144	167	EVENT,
145	168	EMPTY_BUFFER_DONE,
146	169	FILL_BUFFER_DONE,
	170	+#ifndef OMAP_ENHANCEMENT
147	171	REGISTER_BUFFERS
	172	+#endif
148	173
149	174	} type;
150	175
...	...	@@ -183,14 +208,27 @@ public:
183	208	DECLARE_META_INTERFACE(OMXObserver);
184	209
185	210	virtual void onMessage(const omx_message &msg) = 0;
	211	+#ifndef OMAP_ENHANCEMENT
186	212	virtual void registerBuffers(const sp<IMemoryHeap> &mem) = 0;
	213	+#endif
187	214	};
188	215
	216	+#ifdef OMAP_ENHANCEMENT
	217	+typedef void (release_rendered_buffer_callback)(const sp<IMemory>& mem, void cookie);
	218	+#endif
	219	+
189	220	class IOMXRenderer : public IInterface {
190	221	public:
191	222	DECLARE_META_INTERFACE(OMXRenderer);
192	223
193	224	virtual void render(IOMX::buffer_id buffer) = 0;
	225	+#ifdef OMAP_ENHANCEMENT
	226	+ virtual Vector< sp<IMemory> > getBuffers() = 0;
	227	+ virtual bool setCallback(release_rendered_buffer_callback cb, void *cookie) = 0;
	228	+ virtual void set_s3d_frame_layout(uint32_t s3d_mode, uint32_t s3d_fmt, uint32_t s3d_order, uint32_t s3d_subsampling) =0;
	229	+ virtual void resizeRenderer(void* resize_params) = 0;
	230	+ virtual void requestRendererClone(bool enable) = 0;
	231	+#endif
194	232	};
195	233
196	234	////////////////////////////////////////////////////////////////////////////////

...	...	@@ -122,7 +122,9 @@ public:
122	122	virtual player_type playerType() = 0;
123	123	virtual status_t suspend() { return INVALID_OPERATION; }
124	124	virtual status_t resume() { return INVALID_OPERATION; }
125		-
	125	+#ifdef OMAP_ENHANCEMENT
	126	+ virtual status_t requestVideoCloneMode(bool enable) { return INVALID_OPERATION; }
	127	+#endif
126	128	virtual void setNotifyCallback(void* cookie, notify_callback_f notifyFunc) {
127	129	mCookie = cookie; mNotify = notifyFunc; }
128	130	// Invoke a generic method on the player by using opaque parcels

...	...	@@ -32,6 +32,10 @@ enum camcorder_quality {
32	32
33	33	enum video_decoder {
34	34	VIDEO_DECODER_WMV,
	35	+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)
	36	+ VIDEO_DECODER_VP6,
	37	+ VIDEO_DECODER_VP7,
	38	+#endif
35	39	};
36	40
37	41	enum audio_decoder {

...	...	@@ -0,0 +1,127 @@
	1	+/*
	2	+ * Copyright (C) Texas Instruments - http://www.ti.com/
	3	+ *
	4	+ * This library is free software; you can redistribute it and/or
	5	+ * modify it under the terms of the GNU Lesser General Public
	6	+ * License as published by the Free Software Foundation; either
	7	+ * version 2.1 of the License, or (at your option) any later version.
	8	+ *
	9	+ *
	10	+ * This library is distributed in the hope that it will be useful,
	11	+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
	12	+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	13	+ * Lesser General Public License for more details.
	14	+ *
	15	+ *
	16	+ * You should have received a copy of the GNU Lesser General Public
	17	+ * License along with this library; if not, write to the Free Software
	18	+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
	19	+ */
	20	+
	21	+#ifndef OVERLAY_RENDERER_H_
	22	+#define OVERLAY_RENDERER_H_
	23	+
	24	+#include <utils/Log.h>
	25	+#include <OMX_Component.h>
	26	+#include <overlay_common.h>
	27	+#include <media/stagefright/MediaDebug.h>
	28	+
	29	+#include <binder/Parcel.h>
	30	+#include <binder/IMemory.h>
	31	+#include <binder/IInterface.h>
	32	+#include <binder/MemoryBase.h>
	33	+#include <binder/MemoryHeapBase.h>
	34	+
	35	+#include <ui/Overlay.h>
	36	+#include <surfaceflinger/Surface.h>
	37	+#include <surfaceflinger/ISurface.h>
	38	+#include <surfaceflinger/ISurfaceComposer.h>
	39	+#include <surfaceflinger/SurfaceComposerClient.h>
	40	+
	41	+namespace android {
	42	+
	43	+class IOverlayRenderer : public IInterface {
	44	+public:
	45	+ DECLARE_META_INTERFACE(OverlayRenderer);
	46	+ virtual int32_t createOverlayRenderer(uint32_t bufferCount,
	47	+ int32_t displayWidth,
	48	+ int32_t displayHeight,
	49	+ uint32_t colorFormat,
	50	+ int32_t decodedWidth,
	51	+ int32_t decodedHeight,
	52	+ int infoType,
	53	+ void* info)=0;
	54	+
	55	+ virtual void releaseMe()=0;
	56	+ virtual uint32_t getBufferCount()=0;
	57	+ virtual sp<IMemory> getBuffer(uint32_t index) = 0;
	58	+ virtual int32_t dequeueBuffer(uint32_t *index)=0;
	59	+ virtual int32_t queueBuffer(uint32_t index)=0;
	60	+ virtual int32_t setPosition(int32_t x, int32_t y)=0;
	61	+ virtual int32_t setSize(uint32_t w, uint32_t h)=0;
	62	+ virtual int32_t setOrientation(int32_t orientation, uint32_t flags)=0;
	63	+ virtual int32_t setCrop(uint32_t x, uint32_t y, uint32_t w, uint32_t h)=0;
	64	+};
	65	+
	66	+
	67	+class BnOverlayRenderer : public BnInterface<IOverlayRenderer> {
	68	+public:
	69	+ virtual status_t onTransact(uint32_t code, const Parcel &data, Parcel *reply, uint32_t flags = 0);
	70	+};
	71	+
	72	+
	73	+class OverlayRenderer : public BnOverlayRenderer{
	74	+
	75	+public:
	76	+
	77	+ OverlayRenderer();
	78	+ ~OverlayRenderer();
	79	+ int32_t createOverlayRenderer(uint32_t bufferCount,
	80	+ int32_t displayWidth,
	81	+ int32_t displayHeight,
	82	+ uint32_t colorFormat,
	83	+ int32_t decodedWidth,
	84	+ int32_t decodedHeight,
	85	+ int infoType,
	86	+ void* info);
	87	+ void releaseMe();
	88	+ uint32_t getBufferCount() { return mBufferCount; }
	89	+ sp<IMemory> getBuffer(uint32_t index);
	90	+ int32_t dequeueBuffer(uint32_t *index);
	91	+ int32_t queueBuffer(uint32_t index);
	92	+ int32_t setPosition(int32_t x, int32_t y) ;
	93	+ int32_t setSize(uint32_t w, uint32_t h) ;
	94	+ int32_t setCrop(uint32_t x, uint32_t y, uint32_t w, uint32_t h);
	95	+ int32_t setOrientation(int32_t orientation, uint32_t flags);
	96	+
	97	+private:
	98	+
	99	+ int32_t createSurface();
	100	+ int32_t createBuffers();
	101	+
	102	+ int32_t mInitCheck;
	103	+ int32_t mDisplayWidth, mDisplayHeight;
	104	+ int32_t mDecodedWidth, mDecodedHeight;
	105	+ uint32_t mColorFormat;
	106	+ uint32_t mBufferCount;
	107	+ unsigned int mInfoType;
	108	+
	109	+ /* Surface details */
	110	+ sp<Overlay> mOverlay;
	111	+ sp<SurfaceComposerClient> mSurfaceClient;
	112	+ sp<SurfaceControl> mSurfaceControl;
	113	+ sp<ISurface> mISurface;
	114	+
	115	+ sp<MemoryHeapBase> mVideoHeaps[NUM_OVERLAY_BUFFERS_MAX];
	116	+ Vector< sp<IMemory> > mOverlayAddresses;
	117	+
	118	+ /* copy of previously set window values */
	119	+ int32_t win_x;
	120	+ int32_t win_y;
	121	+
	122	+};
	123	+
	124	+}
	125	+
	126	+#endif
	127	+

...	...	@@ -175,6 +175,9 @@ public:
175	175	int getAudioSessionId();
176	176	status_t setAuxEffectSendLevel(float level);
177	177	status_t attachAuxEffect(int effectId);
	178	+#ifdef OMAP_ENHANCEMENT
	179	+ status_t requestVideoCloneMode(bool enable);
	180	+#endif
178	181	private:
179	182	void clear_l();
180	183	status_t seekTo_l(int msec);

...	...	@@ -45,6 +45,10 @@ enum audio_source {
45	45	AUDIO_SOURCE_CAMCORDER = 5,
46	46	AUDIO_SOURCE_VOICE_RECOGNITION = 6,
47	47	AUDIO_SOURCE_VOICE_COMMUNICATION = 7,
	48	+#ifdef OMAP_ENHANCEMENT
	49	+ AUDIO_SOURCE_FM_ANALOG = 8,
	50	+ AUDIO_SOURCE_MAX = AUDIO_SOURCE_FM_ANALOG,
	51	+#else
48	52	#ifdef HAVE_FM_RADIO
49	53	AUDIO_SOURCE_FM_RX = 8,
50	54	AUDIO_SOURCE_FM_RX_A2DP = 9,
...	...	@@ -52,6 +56,7 @@ enum audio_source {
52	56	#else
53	57	AUDIO_SOURCE_MAX = AUDIO_SOURCE_VOICE_COMMUNICATION,
54	58	#endif
	59	+#endif
55	60	AUDIO_SOURCE_LIST_END // must be last - used to validate audio source type
56	61	};
57	62

...	...	@@ -51,7 +51,9 @@ public:
51	51
52	52	void pause(bool playPendingSamples = false);
53	53	void resume();
54		-
	54	+#ifdef OMAP_ENHANCEMENT
	55	+ void flush();
	56	+#endif
55	57	// Returns the timestamp of the last buffer played (in us).
56	58	int64_t getMediaTimeUs();
57	59
...	...	@@ -109,6 +111,10 @@ private:
109	111
110	112	AudioPlayer(const AudioPlayer &);
111	113	AudioPlayer &operator=(const AudioPlayer &);
	114	+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)
	115	+ int64_t mRealTimeInterpolation;
	116	+ int64_t GetSystemTimeuSec();
	117	+#endif
112	118	};
113	119
114	120	} // namespace android

...	...	@@ -63,6 +63,9 @@ private:
63	63	List<sp<IMemory> > mFramesReceived;
64	64	List<sp<IMemory> > mFramesBeingEncoded;
65	65	List<int64_t> mFrameTimes;
	66	+#if defined(OMAP_ENHANCEMENT) && (TARGET_OMAP4)
	67	+ List<uint32_t> mFrameOffset;
	68	+#endif
66	69
67	70	int64_t mStartTimeUs;
68	71	int64_t mFirstFrameTimeUs;
...	...	@@ -77,8 +80,14 @@ private:
77	80
78	81	CameraSource(const sp<Camera> &camera);
79	82
	83	+#ifdef OMAP_ENHANCEMENT
	84	+ void dataCallbackTimestamp(
	85	+ int64_t timestampUs, int32_t msgType, const sp<IMemory> &data,
	86	+ uint32_t offset=0, uint32_t stride=0);
	87	+#else
80	88	void dataCallbackTimestamp(
81	89	int64_t timestampUs, int32_t msgType, const sp<IMemory> &data);
	90	+#endif
82	91
83	92	void releaseQueuedFrames();
84	93	void releaseOneRecordingFrame(const sp<IMemory>& frame);

...	...	@@ -33,10 +33,18 @@ struct ColorConverter {
33	33
34	34	bool isValid() const;
35	35
	36	+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)
	37	+ void convert(
	38	+ size_t width, size_t height,
	39	+ const void *srcBits, size_t srcSkip,
	40	+ void *dstBits, size_t dstSkip,
	41	+ size_t displaywidth=0, size_t displayheight=0,size_t offset=0,bool interlaced=false);
	42	+#else
36	43	void convert(
37	44	size_t width, size_t height,
38	45	const void *srcBits, size_t srcSkip,
39	46	void *dstBits, size_t dstSkip);
	47	+#endif
40	48
41	49	private:
42	50	OMX_COLOR_FORMATTYPE mSrcFormat, mDstFormat;
...	...	@@ -83,6 +91,14 @@ private:
83	91	const uint8_t *blockUV, size_t blockWidth,
84	92	size_t blockHeight, size_t dstSkip);
85	93
	94	+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)
	95	+ void convertYUV420PackedSemiPlanar(
	96	+ size_t width, size_t height,
	97	+ size_t displaywidth, size_t displayheight, size_t offset,
	98	+ const void *srcBits, size_t srcSkip,
	99	+ void *dstBits, size_t dstSkip, bool interlaced);
	100	+#endif
	101	+
86	102	ColorConverter(const ColorConverter &);
87	103	ColorConverter &operator=(const ColorConverter &);
88	104	};

CyanogenMod / android_frameworks_base forked from KellyMahan/android_frameworks_base

Jump to Line

0 notes on commit 1a6862f Show line notes below

GitHub Links

GitHub

Tools

Extras

Documentation

Keyboard Shortcuts (see all)

Site wide shortcuts

Commit list

Pull request list

Issues

Issues Dashboard

Network Graph

Source Code Browsing

Markdown Cheat Sheet

Format Text

Lists

Miscellaneous

Code Examples in Markdown

0 notes on commit `1a6862f` Show line notes below

...	...	@@ -40,6 +40,24 @@ extern android::VideoRenderer *createRendererWithRotation(
40	40	size_t decodedWidth, size_t decodedHeight,
41	41	int32_t rotationDegrees);
42	42
	43	+#ifdef OMAP_ENHANCEMENT
	44	+extern android::VideoRenderer *createRenderer(
	45	+ const android::sp<android::ISurface> &surface,
	46	+ const char *componentName,
	47	+ OMX_COLOR_FORMATTYPE colorFormat,
	48	+ size_t displayWidth, size_t displayHeight,
	49	+ size_t decodedWidth, size_t decodedHeight,
	50	+ int isS3D, int numOfOpBuffers);
	51	+
	52	+extern android::VideoRenderer *createRendererWithRotation(
	53	+ const android::sp<android::ISurface> &surface,
	54	+ const char *componentName,
	55	+ OMX_COLOR_FORMATTYPE colorFormat,
	56	+ size_t displayWidth, size_t displayHeight,
	57	+ size_t decodedWidth, size_t decodedHeight,
	58	+ int32_t rotationDegrees,
	59	+ int isS3D, int numOfOpBuffers);
	60	+#endif
43	61	extern android::OMXPluginBase *createOMXPlugin();
44	62
45	63	#endif // HARDWARE_API_H_

...	...	@@ -27,6 +27,17 @@ extern const char *MEDIA_MIMETYPE_VIDEO_AVC;
27	27	extern const char *MEDIA_MIMETYPE_VIDEO_MPEG4;
28	28	extern const char *MEDIA_MIMETYPE_VIDEO_H263;
29	29	extern const char *MEDIA_MIMETYPE_VIDEO_RAW;
	30	+#if defined(OMAP_ENHANCEMENT)
	31	+#if defined(TARGET_OMAP4)
	32	+extern const char *MEDIA_MIMETYPE_VIDEO_VP6;
	33	+extern const char *MEDIA_MIMETYPE_VIDEO_VP7;
	34	+#endif
	35	+extern const char *MEDIA_MIMETYPE_CONTAINER_ASF;
	36	+extern const char *MEDIA_MIMETYPE_VIDEO_WMV;
	37	+extern const char *MEDIA_MIMETYPE_AUDIO_WMA;
	38	+extern const char *MEDIA_MIMETYPE_AUDIO_WMAPRO;
	39	+extern const char *MEDIA_MIMETYPE_AUDIO_WMALSL;
	40	+#endif
30	41
31	42	extern const char *MEDIA_MIMETYPE_AUDIO_AMR_NB;
32	43	extern const char *MEDIA_MIMETYPE_AUDIO_AMR_WB;
...	...	@@ -41,9 +52,13 @@ extern const char *MEDIA_MIMETYPE_AUDIO_RAW;
41	52	extern const char *MEDIA_MIMETYPE_CONTAINER_MPEG4;
42	53	extern const char *MEDIA_MIMETYPE_CONTAINER_WAV;
43	54	extern const char *MEDIA_MIMETYPE_CONTAINER_OGG;
	55	+
44	56	extern const char *MEDIA_MIMETYPE_CONTAINER_MATROSKA;
45	57	extern const char *MEDIA_MIMETYPE_CONTAINER_MPEG2TS;
46	58
	59	+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)
	60	+extern const char *MEDIA_MIMETYPE_CONTAINER_AVI;
	61	+#endif
47	62	} // namespace android
48	63
49	64	#endif // MEDIA_DEFS_H_

...	...	@@ -40,6 +40,9 @@ enum {
40	40	// Not technically an error.
41	41	INFO_FORMAT_CHANGED = MEDIA_ERROR_BASE - 12,
42	42	INFO_DISCONTINUITY = MEDIA_ERROR_BASE - 13,
	43	+#ifdef OMAP_ENHANCEMENT
	44	+ ERROR_OUT_OF_MEM = MEDIA_ERROR_BASE - 14
	45	+#endif
43	46	};
44	47
45	48	} // namespace android

...	...	@@ -17,9 +17,10 @@
17	17	#ifndef MEDIA_EXTRACTOR_H_
18	18
19	19	#define MEDIA_EXTRACTOR_H_
20		-
21	20	#include <utils/RefBase.h>
22	21
	22	+#include <utils/String8.h>
	23	+
23	24	namespace android {
24	25
25	26	class DataSource;
...	...	@@ -33,10 +34,16 @@ public:
33	34
34	35	virtual size_t countTracks() = 0;
35	36	virtual sp<MediaSource> getTrack(size_t index) = 0;
36		-
	37	+#ifdef OMAP_ENHANCEMENT
37	38	enum GetTrackMetaDataFlags {
38		- kIncludeExtensiveMetaData = 1
	39	+ kIncludeExtensiveMetaData = 1,
	40	+ kSelectFirstSample = 2
39	41	};
	42	+#else
	43	+ enum GetTrackMetaDataFlags {
	44	+ kIncludeExtensiveMetaData = 1
	45	+ };
	46	+#endif
40	47	virtual sp<MetaData> getTrackMetaData(
41	48	size_t index, uint32_t flags = 0) = 0;
42	49
...	...	@@ -64,6 +71,9 @@ private:
64	71	MediaExtractor &operator=(const MediaExtractor &);
65	72	};
66	73
	74	+bool SniffMPEG4(
	75	+ const sp<DataSource> &source, String8 mimeType, float confidence);
	76	+
67	77	} // namespace android
68	78
69	79	#endif // MEDIA_EXTRACTOR_H_

...	...	@@ -25,12 +25,20 @@
25	25	#ifdef USE_GETBUFFERINFO
26	26	#include <binder/IMemory.h>
27	27	#endif
	28	+#ifdef OMAP_ENHANCEMENT
	29	+#include <utils/Vector.h>
	30	+#include "binder/IMemory.h"
	31	+#endif
28	32
29	33	namespace android {
30	34
31	35	class MediaBuffer;
32	36	class MetaData;
33	37
	38	+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)
	39	+struct S3D_params;
	40	+#endif
	41	+
34	42	struct MediaSource : public RefBase {
35	43	MediaSource();
36	44
...	...	@@ -125,6 +133,18 @@ protected:
125	133	private:
126	134	MediaSource(const MediaSource &);
127	135	MediaSource &operator=(const MediaSource &);
	136	+
	137	+public:
	138	+#ifdef OMAP_ENHANCEMENT
	139	+ // Method to share externally allocated buffers with the Codec.
	140	+ virtual void setBuffers(Vector< sp<IMemory> > mBufferAddresse, bool portReconfig = false) {}
	141	+ // Method used to reset read position without consuming the buffer
	142	+ virtual int64_t setSeekTo(const ReadOptions *options) { return 0; }
	143	+ virtual int getNumofOutputBuffers() {return -1; }
	144	+#if defined(TARGET_OMAP4)
	145	+ virtual void parseSEIMessages(S3D_params &mS3Dparams) {}
	146	+#endif
	147	+#endif
128	148	};
129	149
130	150	} // namespace android

...	...	@@ -41,6 +41,10 @@ enum {
41	41	kKeyBitRate = 'brte', // int32_t (bps)
42	42	kKeyESDS = 'esds', // raw data
43	43	kKeyAVCC = 'avcc', // raw data
	44	+#ifdef OMAP_ENHANCEMENT
	45	+ kKeyStreamSpecificData= 'scsd', // raw data
	46	+ kKeyHdr = 'hdrd', // raw data
	47	+#endif
44	48	kKeyVorbisInfo = 'vinf', // raw data
45	49	kKeyVorbisBooks = 'vboo', // raw data
46	50	kKeyWantsNALFragments = 'NALf',
...	...	@@ -79,6 +83,11 @@ enum {
79	83	// video profile and level
80	84	kKeyVideoProfile = 'vprf', // int32_t
81	85	kKeyVideoLevel = 'vlev', // int32_t
	86	+#ifdef OMAP_ENHANCEMENT
	87	+ kKeyNumRefFrames = 'vnrf', // int32_t
	88	+ kKeyVideoFPS = 'vfps', // int32_t
	89	+ kKeyVideoInterlaced = 'vint', // int32_t (bool)
	90	+#endif
82	91
83	92	// Set this key to enable authoring files in 64-bit offset
84	93	kKey64BitFileOffset = 'fobt', // int32_t (bool)
...	...	@@ -102,6 +111,16 @@ enum {
102	111	kKeyValidSamples = 'valD', // int32_t
103	112
104	113	kKeyIsUnreadable = 'unre', // bool (int32_t)
	114	+
	115	+#if defined (OMAP_ENHANCEMENT) && defined (TARGET_OMAP4)
	116	+ kKeyPaddedWidth = 'pwid', // int32_t
	117	+ kKeyPaddedHeight = 'phei', // int32_t
	118	+ kKeyOffset = 'offs', // int32_t
	119	+ kKeyIsExtraData = 'xdta', // int32_t (bool)
	120	+ kKeyS3dSupported ='s3ds', // int32_t (bool)
	121	+ kKeySEIEncodingType ='seit', // int32_t
	122	+ kKeyFrameLayout ='frml', // cstring
	123	+#endif
105	124	};
106	125
107	126	enum {

...	...	@@ -38,6 +38,13 @@ struct OMXCodec : public MediaSource,
38	38	// The client wants to access the output buffer's video
39	39	// data for example for thumbnail extraction.
40	40	kClientNeedsFramebuffer = 4,
	41	+#ifdef OMAP_ENHANCEMENT
	42	+ kPreferThumbnailMode = 0x8,
	43	+ kPreferInterlacedOutputContent = 0x10,
	44	+ MAX_RESOLUTION = 414720, // video resolution for TI Vid Dec
	45	+ MAX_RESOLUTION_WIDTH = 864, // video width for TI Vid Dec
	46	+ MAX_RESOLUTION_HEIGHT = 864, // video height for TI Vid Dec
	47	+#endif
41	48	};
42	49	static sp<MediaSource> Create(
43	50	const sp<IOMX> &omx,
...	...	@@ -46,6 +53,16 @@ struct OMXCodec : public MediaSource,
46	53	const char *matchComponentName = NULL,
47	54	uint32_t flags = 0);
48	55
	56	+#ifdef OMAP_ENHANCEMENT
	57	+ static sp<MediaSource> Create(
	58	+ const sp<IOMX> &omx,
	59	+ const sp<MetaData> &meta, bool createEncoder,
	60	+ const sp<MediaSource> &source,
	61	+ IOMX::node_id &nodeId,
	62	+ const char *matchComponentName = NULL,
	63	+ uint32_t flags = 0);
	64	+#endif
	65	+
49	66	static void setComponentRole(
50	67	const sp<IOMX> &omx, IOMX::node_id node, bool isEncoder,
51	68	const char *mime);
...	...	@@ -54,7 +71,10 @@ struct OMXCodec : public MediaSource,
54	71	virtual status_t stop();
55	72
56	73	virtual sp<MetaData> getFormat();
57		-
	74	+#ifdef OMAP_ENHANCEMENT
	75	+ virtual void setBuffers(Vector< sp<IMemory> > mBufferAddresses, bool portReconfig = false);
	76	+ virtual int getNumofOutputBuffers();
	77	+#endif
58	78	virtual status_t read(
59	79	MediaBuffer *buffer, const ReadOptions options = NULL);
60	80
...	...	@@ -68,7 +88,9 @@ struct OMXCodec : public MediaSource,
68	88	protected:
69	89	virtual ~OMXCodec();
70	90
	91	+#ifndef OMAP_ENHANCEMENT
71	92	private:
	93	+#endif
72	94
73	95	// Make sure mLock is accessible to OMXCodecObserver
74	96	friend class OMXCodecObserver;
...	...	@@ -118,12 +140,21 @@ private:
118	140	kOutputBuffersAreUnreadable = 8192,
119	141	kStoreMetaDataInInputVideoBuffers = 16384,
120	142	kCanNotSetVideoParameters = 32768,
121		- kDoesNotRequireMemcpyOnOutputPort = 65536
	143	+ kDoesNotRequireMemcpyOnOutputPort = 65536,
	144	+#ifdef OMAP_ENHANCEMENT
	145	+ kDecoderNeedsPortReconfiguration = 131072,
	146	+ kDecoderCantRenderSmallClips = 262144,
	147	+ kInterlacedOutputContent = 524288,
	148	+ kThumbnailMode = 1048576,
	149	+#endif
122	150	};
123	151
124	152	struct BufferInfo {
125	153	IOMX::buffer_id mBuffer;
126	154	bool mOwnedByComponent;
	155	+#ifdef OMAP_ENHANCEMENT
	156	+ bool mOwnedByPlayer;
	157	+#endif
127	158	sp<IMemory> mMem;
128	159	size_t mSize;
129	160	void *mData;
...	...	@@ -150,6 +181,11 @@ private:
150	181	sp<MemoryDealer> mDealer[2];
151	182
152	183	State mState;
	184	+#ifdef OMAP_ENHANCEMENT
	185	+ Vector< sp<IMemory> > mExtBufferAddresses;
	186	+ uint32_t mStride;
	187	+ nsecs_t mNSecsToWait;
	188	+#endif
153	189	Vector<BufferInfo> mPortBuffers[2];
154	190	PortStatus mPortStatus[2];
155	191	bool mInitialBufferSubmit;
...	...	@@ -193,6 +229,11 @@ private:
193	229	void setVideoInputFormat(
194	230	const char *mime, const sp<MetaData>& meta);
195	231
	232	+#if defined (TARGET_OMAP4) && defined (OMAP_ENHANCEMENT)
	233	+ status_t setupEncoderPresetParams(int32_t isS3DEnabled);
	234	+ status_t setupEncoderFrameDataContentParams(const sp<MetaData>& meta);
	235	+#endif
	236	+
196	237	status_t setupBitRate(int32_t bitRate);
197	238	status_t setupErrorCorrectionParameters();
198	239	status_t setupH263EncoderParameters(const sp<MetaData>& meta);
...	...	@@ -263,11 +304,22 @@ private:
263	304
264	305	void dumpPortStatus(OMX_U32 portIndex);
265	306
	307	+#ifdef OMAP_ENHANCEMENT
	308	+public:
	309	+#endif
266	310	status_t configureCodec(const sp<MetaData> &meta, uint32_t flags);
267	311
	312	+#ifdef OMAP_ENHANCEMENT
	313	+protected:
	314	+ static uint32_t getComponentQuirks(const char *componentName, bool isEncoder, uint32_t flags = 0);
	315	+ int32_t mVideoFPS;
	316	+#if defined(TARGET_OMAP4)
	317	+ void setS3DMetaDataConfig(int32_t frameContentType);
	318	+#endif
	319	+#else
268	320	static uint32_t getComponentQuirks(
269	321	const char *componentName, bool isEncoder);
270		-
	322	+#endif
271	323	static void findMatchingCodecs(
272	324	const char *mime,
273	325	bool createEncoder, const char *matchComponentName,
...	...	@@ -276,8 +328,59 @@ private:
276	328
277	329	OMXCodec(const OMXCodec &);
278	330	OMXCodec &operator=(const OMXCodec &);
	331	+
	332	+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4) && defined (NPA_BUFFERS)
	333	+ uint32_t mNumberOfNPABuffersSent;
	334	+ uint32_t mThumbnailEOSSent;
	335	+#endif
279	336	};
280	337
	338	+#if defined(OMAP_ENHANCEMENT)
	339	+struct OMXCodecObserver : public BnOMXObserver {
	340	+ OMXCodecObserver() {
	341	+ }
	342	+
	343	+ void setCodec(const sp<OMXCodec> &target) {
	344	+ mTarget = target;
	345	+ }
	346	+
	347	+ // from IOMXObserver
	348	+ virtual void onMessage(const omx_message &msg) {
	349	+ sp<OMXCodec> codec = mTarget.promote();
	350	+
	351	+ if (codec.get() != NULL) {
	352	+ Mutex::Autolock autoLock(codec->mLock);
	353	+ codec->on_message(msg);
	354	+ codec.clear();
	355	+ }
	356	+ }
	357	+
	358	+protected:
	359	+ virtual ~OMXCodecObserver() {}
	360	+
	361	+private:
	362	+ wp<OMXCodec> mTarget;
	363	+
	364	+ OMXCodecObserver(const OMXCodecObserver &);
	365	+ OMXCodecObserver &operator=(const OMXCodecObserver &);
	366	+};
	367	+
	368	+template<class T>
	369	+static void InitOMXParams(T *params) {
	370	+ params->nSize = sizeof(T);
	371	+ params->nVersion.s.nVersionMajor = 1;
	372	+#if defined(OMAP_ENHANCEMENT) && defined(TARGET_OMAP4)
	373	+ //Ducati strict OMX Version check
	374	+ params->nVersion.s.nVersionMinor = 1;
	375	+#else
	376	+ params->nVersion.s.nVersionMinor = 0;
	377	+#endif
	378	+ params->nVersion.s.nRevision = 0;
	379	+ params->nVersion.s.nStep = 0;
	380	+}
	381	+
	382	+#endif
	383	+
281	384	struct CodecProfileLevel {
282	385	OMX_U32 mProfile;
283	386	OMX_U32 mLevel;

...	...	@@ -19,11 +19,49 @@
19	19	#define UTILS_H_
20	20
21	21	#include <stdint.h>
	22	+#ifdef OMAP_ENHANCEMENT
	23	+#include <media/stagefright/openmax/OMX_Types.h>
	24	+#include <media/stagefright/openmax/OMX_Index.h>
	25	+#endif
22	26
23	27	namespace android {
24	28
25	29	#define FOURCC(c1, c2, c3, c4) \
26	30	(c1 << 24 \| c2 << 16 \| c3 << 8 \| c4)
	31	+#ifdef OMAP_ENHANCEMENT
	32	+#ifndef MAKEFOURCC_WMC
	33	+#define MAKEFOURCC_WMC(ch0, ch1, ch2, ch3) \
	34	+ ((OMX_U32)(OMX_U8)(ch0) \| ((OMX_U32)(OMX_U8)(ch1) << 8) \| \
	35	+ ((OMX_U32)(OMX_U8)(ch2) << 16) \| ((OMX_U32)(OMX_U8)(ch3) << 24 ))
	36	+
	37	+#define mmioFOURCC_WMC(ch0, ch1, ch2, ch3) MAKEFOURCC_WMC(ch0, ch1, ch2, ch3)
	38	+#endif
	39	+
	40	+#define FOURCC_WMV3 mmioFOURCC_WMC('W','M','V','3')
	41	+#define FOURCC_WMV2 mmioFOURCC_WMC('W','M','V','2')
	42	+#define FOURCC_WMV1 mmioFOURCC_WMC('W','M','V','1')
	43	+#define FOURCC_WMVA mmioFOURCC_WMC('W','M','V','A')
	44	+#define FOURCC_WVC1 mmioFOURCC_WMC('W','V','C','1')
	45	+
	46	+#define VIDDEC_WMV_ELEMSTREAM 0
	47	+#define VIDDEC_WMV_RCVSTREAM 1
	48	+
	49	+typedef enum VIDDEC_CUSTOM_PARAM_INDEX
	50	+{
	51	+ VideoDecodeCustomParamProcessMode = (OMX_IndexVendorStartUnused + 1),
	52	+ VideoDecodeCustomParamH264BitStreamFormat,
	53	+ VideoDecodeCustomParamWMVProfile,
	54	+ VideoDecodeCustomParamWMVFileType,
	55	+ VideoDecodeCustomParamParserEnabled,
	56	+
	57	+} VIDDEC_CUSTOM_PARAM_INDEX;
	58	+
	59	+typedef struct OMX_PARAM_WMVFILETYPE {
	60	+ OMX_U32 nSize;
	61	+ OMX_VERSIONTYPE nVersion;
	62	+ OMX_U32 nWmvFileType;
	63	+} OMX_PARAM_WMVFILETYPE;
	64	+#endif
27	65
28	66	uint16_t U16_AT(const uint8_t *ptr);
29	67	uint32_t U32_AT(const uint8_t *ptr);

...	...	@@ -19,9 +19,24 @@
19	19	#define VIDEO_RENDERER_H_
20	20
21	21	#include <sys/types.h>
	22	+#ifdef OMAP_ENHANCEMENT
	23	+#include "binder/IMemory.h"
	24	+#include <utils/Vector.h>
	25	+#endif
22	26
23	27	namespace android {
24	28
	29	+#ifdef OMAP_ENHANCEMENT
	30	+typedef void (release_rendered_buffer_callback)(const sp<IMemory>& mem, void cookie);
	31	+typedef struct {
	32	+ uint32_t decoded_width;
	33	+ uint32_t decoded_height;
	34	+ uint32_t buffercount;
	35	+ uint32_t display_width;
	36	+ uint32_t display_height;
	37	+ }render_resize_params;
	38	+#endif
	39	+
25	40	class VideoRenderer {
26	41	public:
27	42	virtual ~VideoRenderer() {}
...	...	@@ -29,6 +44,14 @@ public:
29	44	virtual void render(
30	45	const void data, size_t size, void platformPrivate) = 0;
31	46
	47	+#ifdef OMAP_ENHANCEMENT
	48	+ virtual Vector< sp<IMemory> > getBuffers() = 0;
	49	+ virtual bool setCallback(release_rendered_buffer_callback cb, void *cookie) {return false;}
	50	+ virtual void set_s3d_frame_layout(uint32_t s3d_mode, uint32_t s3d_fmt, uint32_t s3d_order, uint32_t s3d_subsampling) {}
	51	+ virtual void resizeRenderer(void* resize_params) = 0;
	52	+ virtual void requestRendererClone(bool enable) = 0;
	53	+#endif
	54	+
32	55	protected:
33	56	VideoRenderer() {}
34	57

...	...	@@ -58,7 +58,6 @@ extern "C" {
58	58	*/
59	59	#include <OMX_Types.h>
60	60
61		-
62	61	/** The OMX_INDEXTYPE enumeration is used to select a structure when either
63	62	* getting or setting parameters and/or configuration data. Each entry in
64	63	* this enumeration maps to an OMX specified structure. When the